2001-09-20 04:02:59 +04:00
|
|
|
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
2005-06-08 20:38:38 +04:00
|
|
|
* vim: set sw=4 ts=8 et tw=80:
|
1998-03-28 05:44:41 +03:00
|
|
|
*
|
2003-11-15 03:11:16 +03:00
|
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
1998-03-28 05:44:41 +03:00
|
|
|
*
|
2003-11-15 03:11:16 +03:00
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
1998-03-28 05:44:41 +03:00
|
|
|
*
|
2001-09-20 04:02:59 +04:00
|
|
|
* The Original Code is Mozilla Communicator client code, released
|
|
|
|
* March 31, 1998.
|
1999-09-29 03:12:09 +04:00
|
|
|
*
|
2003-11-15 03:11:16 +03:00
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-09-29 03:12:09 +04:00
|
|
|
*
|
2001-01-04 13:13:18 +03:00
|
|
|
* Contributor(s):
|
1999-09-29 03:12:09 +04:00
|
|
|
*
|
2003-11-15 03:11:16 +03:00
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
1998-03-28 05:44:41 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* JS array class.
|
|
|
|
*/
|
1998-06-10 03:04:48 +04:00
|
|
|
#include "jsstddef.h"
|
1998-03-28 05:44:41 +03:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
1998-10-14 14:22:38 +04:00
|
|
|
#include "jstypes.h"
|
|
|
|
#include "jsutil.h" /* Added by JSIFY */
|
1998-03-28 05:44:41 +03:00
|
|
|
#include "jsapi.h"
|
|
|
|
#include "jsarray.h"
|
|
|
|
#include "jsatom.h"
|
2005-04-17 22:31:59 +04:00
|
|
|
#include "jsbool.h"
|
1998-03-28 05:44:41 +03:00
|
|
|
#include "jscntxt.h"
|
|
|
|
#include "jsconfig.h"
|
|
|
|
#include "jsfun.h"
|
|
|
|
#include "jsgc.h"
|
|
|
|
#include "jsinterp.h"
|
|
|
|
#include "jslock.h"
|
|
|
|
#include "jsnum.h"
|
|
|
|
#include "jsobj.h"
|
|
|
|
#include "jsstr.h"
|
|
|
|
|
1998-07-31 04:07:22 +04:00
|
|
|
/* 2^32 - 1 as a number and a string */
|
|
|
|
#define MAXINDEX 4294967295u
|
|
|
|
#define MAXSTR "4294967295"
|
1998-06-09 20:47:00 +04:00
|
|
|
|
2005-06-08 20:38:38 +04:00
|
|
|
/* A useful value for identifying a hole in an array */
|
|
|
|
#define JSVAL_HOLE BOOLEAN_TO_JSVAL(2)
|
|
|
|
|
1998-07-31 04:07:22 +04:00
|
|
|
/*
|
2004-10-05 14:19:07 +04:00
|
|
|
* Determine if the id represents an array index or an XML property index.
|
1998-07-31 04:07:22 +04:00
|
|
|
*
|
1998-06-09 20:47:00 +04:00
|
|
|
* An id is an array index according to ECMA by (15.4):
|
|
|
|
*
|
|
|
|
* "Array objects give special treatment to a certain class of property names.
|
|
|
|
* A property name P (in the form of a string value) is an array index if and
|
1998-07-31 04:07:22 +04:00
|
|
|
* only if ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal
|
1998-06-09 20:47:00 +04:00
|
|
|
* to 2^32-1."
|
1998-07-31 04:07:22 +04:00
|
|
|
*
|
1998-06-09 20:47:00 +04:00
|
|
|
* In our implementation, it would be sufficient to check for JSVAL_IS_INT(id)
|
1998-07-31 04:07:22 +04:00
|
|
|
* except that by using signed 32-bit integers we miss the top half of the
|
1998-06-09 20:47:00 +04:00
|
|
|
* valid range. This function checks the string representation itself; note
|
1998-07-31 04:07:22 +04:00
|
|
|
* that calling a standard conversion routine might allow strings such as
|
1998-06-09 20:47:00 +04:00
|
|
|
* "08" or "4.0" as array indices, which they are not.
|
|
|
|
*/
|
2004-10-05 14:19:07 +04:00
|
|
|
JSBool
|
|
|
|
js_IdIsIndex(jsval id, jsuint *indexp)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
JSString *str;
|
1998-07-31 04:07:22 +04:00
|
|
|
jschar *cp;
|
1998-04-24 04:31:11 +04:00
|
|
|
|
|
|
|
if (JSVAL_IS_INT(id)) {
|
2003-06-12 04:26:40 +04:00
|
|
|
jsint i;
|
|
|
|
i = JSVAL_TO_INT(id);
|
|
|
|
if (i < 0)
|
|
|
|
return JS_FALSE;
|
|
|
|
*indexp = (jsuint)i;
|
|
|
|
return JS_TRUE;
|
1998-04-24 04:31:11 +04:00
|
|
|
}
|
|
|
|
|
2004-10-05 14:19:07 +04:00
|
|
|
/* NB: id should be a string, but jsxml.c may call us with an object id. */
|
|
|
|
if (!JSVAL_IS_STRING(id))
|
|
|
|
return JS_FALSE;
|
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
str = JSVAL_TO_STRING(id);
|
2001-10-25 04:26:38 +04:00
|
|
|
cp = JSSTRING_CHARS(str);
|
|
|
|
if (JS7_ISDEC(*cp) && JSSTRING_LENGTH(str) < sizeof(MAXSTR)) {
|
2003-06-12 04:26:40 +04:00
|
|
|
jsuint index = JS7_UNDEC(*cp++);
|
|
|
|
jsuint oldIndex = 0;
|
|
|
|
jsuint c = 0;
|
|
|
|
if (index != 0) {
|
|
|
|
while (JS7_ISDEC(*cp)) {
|
|
|
|
oldIndex = index;
|
|
|
|
c = JS7_UNDEC(*cp);
|
|
|
|
index = 10*index + c;
|
|
|
|
cp++;
|
|
|
|
}
|
|
|
|
}
|
2004-10-05 14:19:07 +04:00
|
|
|
|
|
|
|
/* Ensure that all characters were consumed and we didn't overflow. */
|
2003-06-12 04:26:40 +04:00
|
|
|
if (*cp == 0 &&
|
|
|
|
(oldIndex < (MAXINDEX / 10) ||
|
|
|
|
(oldIndex == (MAXINDEX / 10) && c < (MAXINDEX % 10))))
|
|
|
|
{
|
|
|
|
*indexp = index;
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
1998-06-09 20:47:00 +04:00
|
|
|
}
|
1998-07-31 04:07:22 +04:00
|
|
|
return JS_FALSE;
|
1998-04-24 04:31:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
ValueIsLength(JSContext *cx, jsval v, jsuint *lengthp)
|
|
|
|
{
|
|
|
|
jsint i;
|
2001-10-26 06:35:01 +04:00
|
|
|
jsdouble d;
|
1998-07-31 04:07:22 +04:00
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
if (JSVAL_IS_INT(v)) {
|
2001-10-26 06:35:01 +04:00
|
|
|
i = JSVAL_TO_INT(v);
|
1999-09-21 22:58:51 +04:00
|
|
|
if (i < 0) {
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
|
2001-10-26 06:35:01 +04:00
|
|
|
JSMSG_BAD_ARRAY_LENGTH);
|
1999-09-21 22:58:51 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
2001-10-26 06:35:01 +04:00
|
|
|
*lengthp = (jsuint) i;
|
|
|
|
return JS_TRUE;
|
1998-07-31 04:07:22 +04:00
|
|
|
}
|
2004-10-05 14:19:07 +04:00
|
|
|
|
2001-10-26 06:35:01 +04:00
|
|
|
if (!js_ValueToNumber(cx, v, &d)) {
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
|
2002-09-20 22:45:05 +04:00
|
|
|
JSMSG_BAD_ARRAY_LENGTH);
|
|
|
|
return JS_FALSE;
|
2001-10-26 06:35:01 +04:00
|
|
|
}
|
|
|
|
if (!js_DoubleToECMAUint32(cx, d, (uint32 *)lengthp)) {
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
|
2002-09-20 22:45:05 +04:00
|
|
|
JSMSG_BAD_ARRAY_LENGTH);
|
|
|
|
return JS_FALSE;
|
1998-04-24 04:31:11 +04:00
|
|
|
}
|
2001-10-26 06:35:01 +04:00
|
|
|
if (JSDOUBLE_IS_NaN(d) || d != *lengthp) {
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
|
|
|
|
JSMSG_BAD_ARRAY_LENGTH);
|
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
return JS_TRUE;
|
1998-04-24 04:31:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
JSBool
|
|
|
|
js_GetLengthProperty(JSContext *cx, JSObject *obj, jsuint *lengthp)
|
|
|
|
{
|
|
|
|
jsid id;
|
|
|
|
jsint i;
|
|
|
|
jsval v;
|
|
|
|
|
2004-10-05 14:19:07 +04:00
|
|
|
id = ATOM_TO_JSID(cx->runtime->atomState.lengthAtom);
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, &v))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-04-24 04:31:11 +04:00
|
|
|
|
|
|
|
/* Short-circuit, because js_ValueToECMAUint32 fails when
|
|
|
|
* called during init time.
|
|
|
|
*/
|
|
|
|
if (JSVAL_IS_INT(v)) {
|
2003-06-12 04:26:40 +04:00
|
|
|
i = JSVAL_TO_INT(v);
|
|
|
|
/* jsuint cast does ToUint32. */
|
|
|
|
*lengthp = (jsuint)i;
|
|
|
|
return JS_TRUE;
|
1998-04-24 04:31:11 +04:00
|
|
|
}
|
|
|
|
return js_ValueToECMAUint32(cx, v, (uint32 *)lengthp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
2005-10-02 10:27:07 +04:00
|
|
|
IndexToValue(JSContext *cx, jsuint index, jsval *vp)
|
1998-04-24 04:31:11 +04:00
|
|
|
{
|
2005-10-02 10:27:07 +04:00
|
|
|
if (index <= JSVAL_INT_MAX) {
|
|
|
|
*vp = INT_TO_JSVAL(index);
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_TRUE;
|
1998-04-24 04:31:11 +04:00
|
|
|
}
|
2005-10-02 10:27:07 +04:00
|
|
|
return js_NewDoubleValue(cx, (jsdouble)index, vp);
|
1998-04-24 04:31:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
2005-10-02 10:27:07 +04:00
|
|
|
IndexToId(JSContext *cx, jsuint index, jsid *idp)
|
1998-04-24 04:31:11 +04:00
|
|
|
{
|
|
|
|
JSString *str;
|
|
|
|
JSAtom *atom;
|
|
|
|
|
2005-10-02 10:27:07 +04:00
|
|
|
if (index <= JSVAL_INT_MAX) {
|
|
|
|
*idp = INT_TO_JSID(index);
|
1998-03-28 05:44:41 +03:00
|
|
|
} else {
|
2005-10-02 10:27:07 +04:00
|
|
|
str = js_NumberToString(cx, (jsdouble)index);
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!str)
|
|
|
|
return JS_FALSE;
|
|
|
|
atom = js_AtomizeString(cx, str, 0);
|
|
|
|
if (!atom)
|
|
|
|
return JS_FALSE;
|
2004-10-05 14:19:07 +04:00
|
|
|
*idp = ATOM_TO_JSID(atom);
|
1998-04-24 04:31:11 +04:00
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
2005-07-13 20:38:46 +04:00
|
|
|
static JSBool
|
|
|
|
PropertyExists(JSContext *cx, JSObject *obj, jsid id, JSBool *foundp)
|
|
|
|
{
|
|
|
|
JSObject *obj2;
|
|
|
|
JSProperty *prop;
|
|
|
|
|
|
|
|
if (!OBJ_LOOKUP_PROPERTY(cx, obj, id, &obj2, &prop))
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
*foundp = prop != NULL;
|
2006-02-25 01:12:32 +03:00
|
|
|
if (*foundp)
|
2005-07-13 20:38:46 +04:00
|
|
|
OBJ_DROP_PROPERTY(cx, obj2, prop);
|
|
|
|
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
2005-10-02 10:27:07 +04:00
|
|
|
#define JSID_HOLE JSVAL_NULL
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
IndexToExistingId(JSContext *cx, JSObject *obj, jsuint index, jsid *idp)
|
|
|
|
{
|
|
|
|
JSBool exists;
|
|
|
|
|
|
|
|
if (!IndexToId(cx, index, idp))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!PropertyExists(cx, obj, *idp, &exists))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!exists)
|
|
|
|
*idp = JSID_HOLE;
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
JSBool
|
|
|
|
js_SetLengthProperty(JSContext *cx, JSObject *obj, jsuint length)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
|
|
|
jsval v;
|
1998-04-24 04:31:11 +04:00
|
|
|
jsid id;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!IndexToValue(cx, length, &v))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
2004-10-05 14:19:07 +04:00
|
|
|
id = ATOM_TO_JSID(cx->runtime->atomState.lengthAtom);
|
1998-04-24 04:31:11 +04:00
|
|
|
return OBJ_SET_PROPERTY(cx, obj, id, &v);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
JSBool
|
|
|
|
js_HasLengthProperty(JSContext *cx, JSObject *obj, jsuint *lengthp)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
JSErrorReporter older;
|
|
|
|
jsid id;
|
|
|
|
JSBool ok;
|
1998-03-28 05:44:41 +03:00
|
|
|
jsval v;
|
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
older = JS_SetErrorReporter(cx, NULL);
|
2004-10-05 14:19:07 +04:00
|
|
|
id = ATOM_TO_JSID(cx->runtime->atomState.lengthAtom);
|
1998-04-24 04:31:11 +04:00
|
|
|
ok = OBJ_GET_PROPERTY(cx, obj, id, &v);
|
|
|
|
JS_SetErrorReporter(cx, older);
|
|
|
|
if (!ok)
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-04-24 04:31:11 +04:00
|
|
|
return ValueIsLength(cx, v, lengthp);
|
|
|
|
}
|
|
|
|
|
2006-04-27 04:39:43 +04:00
|
|
|
JSBool
|
|
|
|
js_IsArrayLike(JSContext *cx, JSObject *obj, JSBool *answerp, jsuint *lengthp)
|
|
|
|
{
|
|
|
|
JSClass *clasp;
|
|
|
|
|
|
|
|
clasp = OBJ_GET_CLASS(cx, obj);
|
|
|
|
*answerp = (clasp == &js_ArgumentsClass || clasp == &js_ArrayClass);
|
|
|
|
if (!*answerp) {
|
|
|
|
*lengthp = 0;
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
return js_GetLengthProperty(cx, obj, lengthp);
|
|
|
|
}
|
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
/*
|
|
|
|
* This get function is specific to Array.prototype.length and other array
|
|
|
|
* instance length properties. It calls back through the class get function
|
|
|
|
* in case some magic happens there (see call_getProperty in jsfun.c).
|
|
|
|
*/
|
|
|
|
static JSBool
|
|
|
|
array_length_getter(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
|
|
|
|
{
|
|
|
|
return OBJ_GET_CLASS(cx, obj)->getProperty(cx, obj, id, vp);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_length_setter(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
|
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
jsuint newlen, oldlen, slot;
|
|
|
|
jsid id2;
|
1998-03-28 05:44:41 +03:00
|
|
|
jsval junk;
|
|
|
|
|
1999-09-21 22:58:51 +04:00
|
|
|
if (!ValueIsLength(cx, *vp, &newlen))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!js_GetLengthProperty(cx, obj, &oldlen))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
slot = oldlen;
|
|
|
|
while (slot > newlen) {
|
|
|
|
--slot;
|
|
|
|
if (!IndexToId(cx, slot, &id2))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!OBJ_DELETE_PROPERTY(cx, obj, id2, &junk))
|
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
1998-04-24 04:31:11 +04:00
|
|
|
return IndexToValue(cx, newlen, vp);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_addProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
|
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
jsuint index, length;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2004-10-05 14:19:07 +04:00
|
|
|
if (!js_IdIsIndex(id, &index))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_TRUE;
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!js_GetLengthProperty(cx, obj, &length))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-04-24 04:31:11 +04:00
|
|
|
if (index >= length) {
|
2003-06-12 04:26:40 +04:00
|
|
|
length = index + 1;
|
|
|
|
return js_SetLengthProperty(cx, obj, length);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
1998-04-24 04:31:11 +04:00
|
|
|
return JS_TRUE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
|
|
|
|
{
|
1998-10-14 14:22:38 +04:00
|
|
|
return js_TryValueOf(cx, obj, type, vp);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
JSClass js_ArrayClass = {
|
|
|
|
"Array",
|
2006-04-20 03:36:16 +04:00
|
|
|
JSCLASS_HAS_CACHED_PROTO(JSProto_Array),
|
1998-04-24 04:31:11 +04:00
|
|
|
array_addProperty, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
|
1999-11-12 00:52:35 +03:00
|
|
|
JS_EnumerateStub, JS_ResolveStub, array_convert, JS_FinalizeStub,
|
|
|
|
JSCLASS_NO_OPTIONAL_MEMBERS
|
1998-03-28 05:44:41 +03:00
|
|
|
};
|
|
|
|
|
2006-01-11 08:18:30 +03:00
|
|
|
enum ArrayToStringOp {
|
2005-11-20 04:12:58 +03:00
|
|
|
TO_STRING,
|
|
|
|
TO_LOCALE_STRING,
|
|
|
|
TO_SOURCE
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When op is TO_STRING or TO_LOCALE_STRING sep indicates a separator to use
|
|
|
|
* or "," when sep is NULL.
|
|
|
|
* When op is TO_SOURCE sep must be NULL.
|
|
|
|
*/
|
1998-03-28 05:44:41 +03:00
|
|
|
static JSBool
|
2006-01-11 08:18:30 +03:00
|
|
|
array_join_sub(JSContext *cx, JSObject *obj, enum ArrayToStringOp op,
|
2005-11-20 04:12:58 +03:00
|
|
|
JSString *sep, jsval *rval)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
JSBool ok;
|
|
|
|
jsuint length, index;
|
|
|
|
jschar *chars, *ochars;
|
2005-11-20 04:12:58 +03:00
|
|
|
size_t nchars, growth, seplen, tmplen, extratail;
|
1998-03-28 05:44:41 +03:00
|
|
|
const jschar *sepstr;
|
2005-11-20 04:12:58 +03:00
|
|
|
jsid id;
|
1998-03-28 05:44:41 +03:00
|
|
|
JSString *str;
|
1998-10-14 14:22:38 +04:00
|
|
|
JSHashEntry *he;
|
2000-08-10 01:46:03 +04:00
|
|
|
JSObject *obj2;
|
2004-12-07 02:17:19 +03:00
|
|
|
int stackDummy;
|
|
|
|
|
|
|
|
if (!JS_CHECK_STACK_SIZE(cx, stackDummy)) {
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_OVER_RECURSED);
|
|
|
|
return JS_FALSE;
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
ok = js_GetLengthProperty(cx, obj, &length);
|
|
|
|
if (!ok)
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-04-24 04:31:11 +04:00
|
|
|
|
2001-11-07 03:15:44 +03:00
|
|
|
he = js_EnterSharpObject(cx, obj, NULL, &chars);
|
|
|
|
if (!he)
|
|
|
|
return JS_FALSE;
|
2005-12-08 01:42:06 +03:00
|
|
|
#ifdef DEBUG
|
|
|
|
growth = (size_t) -1;
|
|
|
|
#endif
|
|
|
|
|
2005-11-20 04:12:58 +03:00
|
|
|
if (op == TO_SOURCE) {
|
2003-06-12 04:26:40 +04:00
|
|
|
if (IS_SHARP(he)) {
|
1998-04-24 04:31:11 +04:00
|
|
|
#if JS_HAS_SHARP_VARS
|
2003-06-12 04:26:40 +04:00
|
|
|
nchars = js_strlen(chars);
|
1998-03-28 05:44:41 +03:00
|
|
|
#else
|
2003-06-12 04:26:40 +04:00
|
|
|
chars[0] = '[';
|
|
|
|
chars[1] = ']';
|
|
|
|
chars[2] = 0;
|
|
|
|
nchars = 2;
|
1998-03-28 05:44:41 +03:00
|
|
|
#endif
|
2003-06-12 04:26:40 +04:00
|
|
|
goto make_string;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2005-11-20 04:12:58 +03:00
|
|
|
* Always allocate 2 extra chars for closing ']' and terminating 0
|
|
|
|
* and then preallocate 1 + extratail to include starting '['.
|
2003-06-12 04:26:40 +04:00
|
|
|
*/
|
2005-11-20 04:12:58 +03:00
|
|
|
extratail = 2;
|
|
|
|
growth = (1 + extratail) * sizeof(jschar);
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!chars) {
|
|
|
|
nchars = 0;
|
|
|
|
chars = (jschar *) malloc(growth);
|
|
|
|
if (!chars)
|
|
|
|
goto done;
|
|
|
|
} else {
|
|
|
|
MAKE_SHARP(he);
|
|
|
|
nchars = js_strlen(chars);
|
2006-02-27 20:32:22 +03:00
|
|
|
growth += nchars * sizeof(jschar);
|
|
|
|
chars = (jschar *)realloc((ochars = chars), growth);
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!chars) {
|
|
|
|
free(ochars);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
chars[nchars++] = '[';
|
2005-11-20 04:12:58 +03:00
|
|
|
JS_ASSERT(sep == NULL);
|
|
|
|
sepstr = NULL; /* indicates to use ", " as separator */
|
|
|
|
seplen = 2;
|
1998-03-28 05:44:41 +03:00
|
|
|
} else {
|
2001-11-07 03:15:44 +03:00
|
|
|
/*
|
|
|
|
* Free any sharp variable definition in chars. Normally, we would
|
|
|
|
* MAKE_SHARP(he) so that only the first sharp variable annotation is
|
|
|
|
* a definition, and all the rest are references, but in the current
|
2005-11-20 04:12:58 +03:00
|
|
|
* case of (op != TO_SOURCE), we don't need chars at all.
|
2001-11-07 03:15:44 +03:00
|
|
|
*/
|
|
|
|
if (chars)
|
|
|
|
JS_free(cx, chars);
|
|
|
|
chars = NULL;
|
|
|
|
nchars = 0;
|
2005-11-20 04:12:58 +03:00
|
|
|
extratail = 1; /* allocate extra char for terminating 0 */
|
2001-11-07 03:15:44 +03:00
|
|
|
|
|
|
|
/* Return the empty string on a cycle as well as on empty join. */
|
|
|
|
if (IS_BUSY(he) || length == 0) {
|
|
|
|
js_LeaveSharpObject(cx, NULL);
|
2003-06-12 04:26:40 +04:00
|
|
|
*rval = JS_GetEmptyStringValue(cx);
|
|
|
|
return ok;
|
|
|
|
}
|
2001-11-07 03:15:44 +03:00
|
|
|
|
|
|
|
/* Flag he as BUSY so we can distinguish a cycle from a join-point. */
|
|
|
|
MAKE_BUSY(he);
|
2005-11-20 04:12:58 +03:00
|
|
|
|
|
|
|
if (sep) {
|
|
|
|
sepstr = JSSTRING_CHARS(sep);
|
|
|
|
seplen = JSSTRING_LENGTH(sep);
|
|
|
|
} else {
|
|
|
|
sepstr = NULL; /* indicates to use "," as separator */
|
|
|
|
seplen = 1;
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2005-10-20 22:58:24 +04:00
|
|
|
/* Use rval to locally root each element value as we loop and convert. */
|
|
|
|
#define v (*rval)
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
for (index = 0; index < length; index++) {
|
2005-11-20 04:12:58 +03:00
|
|
|
if (op != TO_SOURCE) {
|
|
|
|
ok = JS_GetElement(cx, obj, index, &v);
|
|
|
|
} else {
|
|
|
|
ok = IndexToExistingId(cx, obj, index, &id);
|
|
|
|
if (!ok)
|
|
|
|
goto done;
|
|
|
|
if (id == JSID_HOLE) {
|
|
|
|
str = cx->runtime->emptyString;
|
2006-04-27 01:33:01 +04:00
|
|
|
/* For tail holes always append single "," and not ", ". */
|
|
|
|
if (index + 1 == length)
|
2005-11-20 04:12:58 +03:00
|
|
|
seplen = 1;
|
|
|
|
goto got_str;
|
|
|
|
}
|
|
|
|
ok = OBJ_GET_PROPERTY(cx, obj, id, &v);
|
|
|
|
}
|
|
|
|
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!ok)
|
|
|
|
goto done;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2006-04-27 01:33:01 +04:00
|
|
|
if (op != TO_SOURCE && (JSVAL_IS_VOID(v) || JSVAL_IS_NULL(v))) {
|
2003-06-12 04:26:40 +04:00
|
|
|
str = cx->runtime->emptyString;
|
2000-08-10 01:46:03 +04:00
|
|
|
} else {
|
2005-11-20 04:12:58 +03:00
|
|
|
if (op == TO_LOCALE_STRING) {
|
2001-11-07 03:15:44 +03:00
|
|
|
if (!js_ValueToObject(cx, v, &obj2) ||
|
|
|
|
!js_TryMethod(cx, obj2,
|
2001-10-25 04:26:38 +04:00
|
|
|
cx->runtime->atomState.toLocaleStringAtom,
|
|
|
|
0, NULL, &v)) {
|
2001-11-07 03:15:44 +03:00
|
|
|
str = NULL;
|
|
|
|
} else {
|
|
|
|
str = js_ValueToString(cx, v);
|
2001-10-25 04:26:38 +04:00
|
|
|
}
|
2005-11-20 04:12:58 +03:00
|
|
|
} else if (op == TO_STRING) {
|
|
|
|
str = js_ValueToString(cx, v);
|
2001-11-07 03:15:44 +03:00
|
|
|
} else {
|
2005-11-20 04:12:58 +03:00
|
|
|
JS_ASSERT(op == TO_SOURCE);
|
|
|
|
str = js_ValueToSource(cx, v);
|
2001-11-07 03:15:44 +03:00
|
|
|
}
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!str) {
|
|
|
|
ok = JS_FALSE;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-20 04:12:58 +03:00
|
|
|
/* Do not append separator after the last element. */
|
|
|
|
if (index + 1 == length)
|
|
|
|
seplen = 0;
|
|
|
|
|
|
|
|
got_str:
|
|
|
|
/* Allocate 1 at end for closing bracket and zero. */
|
|
|
|
growth = (nchars + JSSTRING_LENGTH(str) + seplen + extratail)
|
|
|
|
* sizeof(jschar);
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!chars) {
|
|
|
|
chars = (jschar *) malloc(growth);
|
|
|
|
if (!chars)
|
|
|
|
goto done;
|
|
|
|
} else {
|
|
|
|
chars = (jschar *) realloc((ochars = chars), growth);
|
|
|
|
if (!chars) {
|
|
|
|
free(ochars);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-10-25 04:26:38 +04:00
|
|
|
tmplen = JSSTRING_LENGTH(str);
|
|
|
|
js_strncpy(&chars[nchars], JSSTRING_CHARS(str), tmplen);
|
|
|
|
nchars += tmplen;
|
2005-11-20 04:12:58 +03:00
|
|
|
|
|
|
|
if (seplen) {
|
|
|
|
if (sepstr) {
|
|
|
|
js_strncpy(&chars[nchars], sepstr, seplen);
|
|
|
|
} else {
|
|
|
|
JS_ASSERT(seplen == 1 || seplen == 2);
|
|
|
|
chars[nchars] = ',';
|
|
|
|
if (seplen == 2)
|
|
|
|
chars[nchars + 1] = ' ';
|
|
|
|
}
|
|
|
|
nchars += seplen;
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
done:
|
2005-11-20 04:12:58 +03:00
|
|
|
if (op == TO_SOURCE) {
|
|
|
|
if (chars)
|
2003-06-12 04:26:40 +04:00
|
|
|
chars[nchars++] = ']';
|
2001-11-07 03:15:44 +03:00
|
|
|
} else {
|
|
|
|
CLEAR_BUSY(he);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
2001-11-07 03:15:44 +03:00
|
|
|
js_LeaveSharpObject(cx, NULL);
|
1998-03-28 05:44:41 +03:00
|
|
|
if (!ok) {
|
2003-06-12 04:26:40 +04:00
|
|
|
if (chars)
|
|
|
|
free(chars);
|
|
|
|
return ok;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2005-10-20 22:58:24 +04:00
|
|
|
#undef v
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
make_string:
|
|
|
|
if (!chars) {
|
2003-06-12 04:26:40 +04:00
|
|
|
JS_ReportOutOfMemory(cx);
|
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
chars[nchars] = 0;
|
2005-12-08 01:42:06 +03:00
|
|
|
JS_ASSERT(growth == (size_t)-1 || (nchars + 1) * sizeof(jschar) == growth);
|
1998-03-28 05:44:41 +03:00
|
|
|
str = js_NewString(cx, chars, nchars, 0);
|
|
|
|
if (!str) {
|
2003-06-12 04:26:40 +04:00
|
|
|
free(chars);
|
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
*rval = STRING_TO_JSVAL(str);
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
#if JS_HAS_TOSOURCE
|
|
|
|
static JSBool
|
|
|
|
array_toSource(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
2003-06-12 04:26:40 +04:00
|
|
|
jsval *rval)
|
1998-04-24 04:31:11 +04:00
|
|
|
{
|
2005-11-20 04:12:58 +03:00
|
|
|
return array_join_sub(cx, obj, TO_SOURCE, NULL, rval);
|
1998-04-24 04:31:11 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
static JSBool
|
|
|
|
array_toString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
2003-06-12 04:26:40 +04:00
|
|
|
jsval *rval)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
2006-04-27 01:33:01 +04:00
|
|
|
return array_join_sub(cx, obj, TO_STRING, NULL, rval);
|
2000-08-10 01:46:03 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_toLocaleString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
2003-06-12 04:26:40 +04:00
|
|
|
jsval *rval)
|
2000-08-10 01:46:03 +04:00
|
|
|
{
|
|
|
|
/*
|
2001-03-10 03:20:42 +03:00
|
|
|
* Passing comma here as the separator. Need a way to get a
|
2001-01-04 13:13:18 +03:00
|
|
|
* locale-specific version.
|
2000-08-10 01:46:03 +04:00
|
|
|
*/
|
2005-11-20 04:12:58 +03:00
|
|
|
return array_join_sub(cx, obj, TO_LOCALE_STRING, NULL, rval);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2002-03-14 03:10:31 +03:00
|
|
|
static JSBool
|
|
|
|
InitArrayElements(JSContext *cx, JSObject *obj, jsuint length, jsval *vector)
|
|
|
|
{
|
|
|
|
jsuint index;
|
|
|
|
jsid id;
|
|
|
|
|
|
|
|
for (index = 0; index < length; index++) {
|
2005-06-08 20:38:38 +04:00
|
|
|
JS_ASSERT(vector[index] != JSVAL_HOLE);
|
|
|
|
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!IndexToId(cx, index, &id))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!OBJ_SET_PROPERTY(cx, obj, id, &vector[index]))
|
|
|
|
return JS_FALSE;
|
2002-03-14 03:10:31 +03:00
|
|
|
}
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
static JSBool
|
1998-04-24 04:31:11 +04:00
|
|
|
InitArrayObject(JSContext *cx, JSObject *obj, jsuint length, jsval *vector)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
jsval v;
|
|
|
|
jsid id;
|
|
|
|
|
|
|
|
if (!IndexToValue(cx, length, &v))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
2004-10-05 14:19:07 +04:00
|
|
|
id = ATOM_TO_JSID(cx->runtime->atomState.lengthAtom);
|
1999-06-23 18:18:56 +04:00
|
|
|
if (!OBJ_DEFINE_PROPERTY(cx, obj, id, v,
|
|
|
|
array_length_getter, array_length_setter,
|
|
|
|
JSPROP_PERMANENT,
|
|
|
|
NULL)) {
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
if (!vector)
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_TRUE;
|
2002-03-14 03:10:31 +03:00
|
|
|
return InitArrayElements(cx, obj, length, vector);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2003-06-12 04:26:40 +04:00
|
|
|
/*
|
|
|
|
* Perl-inspired join, reverse, and sort.
|
|
|
|
*/
|
|
|
|
static JSBool
|
|
|
|
array_join(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
|
|
|
JSString *str;
|
|
|
|
|
2005-11-20 04:12:58 +03:00
|
|
|
if (JSVAL_IS_VOID(argv[0])) {
|
|
|
|
str = NULL;
|
|
|
|
} else {
|
|
|
|
str = js_ValueToString(cx, argv[0]);
|
|
|
|
if (!str)
|
|
|
|
return JS_FALSE;
|
|
|
|
argv[0] = STRING_TO_JSVAL(str);
|
|
|
|
}
|
|
|
|
return array_join_sub(cx, obj, TO_STRING, str, rval);
|
2003-06-12 04:26:40 +04:00
|
|
|
}
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
static JSBool
|
|
|
|
array_reverse(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
2003-06-12 04:26:40 +04:00
|
|
|
jsval *rval)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
jsuint len, half, i;
|
|
|
|
jsid id, id2;
|
2005-10-11 03:33:16 +04:00
|
|
|
jsval *tmproot, *tmproot2;
|
2005-07-13 20:38:46 +04:00
|
|
|
JSBool idexists, id2exists;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!js_GetLengthProperty(cx, obj, &len))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2005-10-11 03:33:16 +04:00
|
|
|
/*
|
|
|
|
* Use argv[argc] and argv[argc + 1] as local roots to hold temporarily
|
|
|
|
* array elements for GC-safe swap.
|
|
|
|
*/
|
|
|
|
tmproot = argv + argc;
|
|
|
|
tmproot2 = argv + argc + 1;
|
1998-04-24 04:31:11 +04:00
|
|
|
half = len / 2;
|
|
|
|
for (i = 0; i < half; i++) {
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!IndexToId(cx, i, &id))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!IndexToId(cx, len - i - 1, &id2))
|
|
|
|
return JS_FALSE;
|
1999-04-27 19:18:57 +04:00
|
|
|
|
2005-07-13 20:38:46 +04:00
|
|
|
/* Check for holes to make sure they don't get filled. */
|
|
|
|
if (!PropertyExists(cx, obj, id, &idexists) ||
|
|
|
|
!PropertyExists(cx, obj, id2, &id2exists)) {
|
2002-02-23 06:49:27 +03:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
1999-04-27 19:18:57 +04:00
|
|
|
|
2005-10-02 10:27:07 +04:00
|
|
|
/*
|
2005-07-18 22:44:22 +04:00
|
|
|
* Get both of the values now. Note that we don't use v, or v2 based on
|
|
|
|
* idexists and id2exists.
|
|
|
|
*/
|
2005-10-11 03:33:16 +04:00
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, tmproot) ||
|
|
|
|
!OBJ_GET_PROPERTY(cx, obj, id2, tmproot2)) {
|
2005-07-18 22:44:22 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
|
2005-07-13 20:38:46 +04:00
|
|
|
if (idexists) {
|
2005-10-11 03:33:16 +04:00
|
|
|
if (!OBJ_SET_PROPERTY(cx, obj, id2, tmproot))
|
2005-07-13 20:38:46 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
} else {
|
2005-10-11 03:33:16 +04:00
|
|
|
if (!OBJ_DELETE_PROPERTY(cx, obj, id2, tmproot))
|
2005-07-13 20:38:46 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
if (id2exists) {
|
2005-10-11 03:33:16 +04:00
|
|
|
if (!OBJ_SET_PROPERTY(cx, obj, id, tmproot2))
|
2005-07-13 20:38:46 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
} else {
|
2005-10-11 03:33:16 +04:00
|
|
|
if (!OBJ_DELETE_PROPERTY(cx, obj, id, tmproot2))
|
2005-07-13 20:38:46 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
*rval = OBJECT_TO_JSVAL(obj);
|
|
|
|
return JS_TRUE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2002-03-13 04:50:13 +03:00
|
|
|
typedef struct HSortArgs {
|
1998-03-28 05:44:41 +03:00
|
|
|
void *vec;
|
|
|
|
size_t elsize;
|
|
|
|
void *pivot;
|
|
|
|
JSComparator cmp;
|
|
|
|
void *arg;
|
2003-02-27 04:43:44 +03:00
|
|
|
JSBool fastcopy;
|
2002-03-13 04:50:13 +03:00
|
|
|
} HSortArgs;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2005-11-16 13:02:57 +03:00
|
|
|
static JSBool
|
|
|
|
sort_compare(void *arg, const void *a, const void *b, int *result);
|
2001-01-04 13:13:18 +03:00
|
|
|
|
2002-05-27 09:53:57 +04:00
|
|
|
static int
|
2005-11-16 13:02:57 +03:00
|
|
|
sort_compare_strings(void *arg, const void *a, const void *b, int *result);
|
2002-05-27 09:53:57 +04:00
|
|
|
|
2005-11-16 13:02:57 +03:00
|
|
|
static JSBool
|
2003-02-27 04:43:44 +03:00
|
|
|
HeapSortHelper(JSBool building, HSortArgs *hsa, size_t lo, size_t hi)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
2002-03-13 04:50:13 +03:00
|
|
|
void *pivot, *vec, *vec2, *arg, *a, *b;
|
2001-01-04 13:13:18 +03:00
|
|
|
size_t elsize;
|
|
|
|
JSComparator cmp;
|
2003-02-27 04:43:44 +03:00
|
|
|
JSBool fastcopy;
|
|
|
|
size_t j, hiDiv2;
|
2005-11-16 13:02:57 +03:00
|
|
|
int cmp_result;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2003-02-27 04:43:44 +03:00
|
|
|
pivot = hsa->pivot;
|
|
|
|
vec = hsa->vec;
|
|
|
|
elsize = hsa->elsize;
|
2002-03-13 04:50:13 +03:00
|
|
|
vec2 = (char *)vec - 2 * elsize;
|
2003-02-27 04:43:44 +03:00
|
|
|
cmp = hsa->cmp;
|
|
|
|
arg = hsa->arg;
|
2001-01-04 13:13:18 +03:00
|
|
|
|
2003-02-27 04:43:44 +03:00
|
|
|
fastcopy = hsa->fastcopy;
|
|
|
|
#define MEMCPY(p,q,n) \
|
|
|
|
(fastcopy ? (void)(*(jsval*)(p) = *(jsval*)(q)) : (void)memcpy(p, q, n))
|
2005-11-16 13:02:57 +03:00
|
|
|
#define CALL_CMP(a, b) \
|
|
|
|
if (!cmp(arg, (a), (b), &cmp_result)) return JS_FALSE;
|
2001-01-04 13:13:18 +03:00
|
|
|
|
2002-03-13 04:50:13 +03:00
|
|
|
if (lo == 1) {
|
|
|
|
j = 2;
|
|
|
|
b = (char *)vec + elsize;
|
2005-11-16 13:02:57 +03:00
|
|
|
if (j < hi) {
|
|
|
|
CALL_CMP(vec, b);
|
|
|
|
if (cmp_result < 0)
|
|
|
|
j++;
|
|
|
|
}
|
2002-03-13 04:50:13 +03:00
|
|
|
a = (char *)vec + (hi - 1) * elsize;
|
|
|
|
b = (char *)vec2 + j * elsize;
|
2003-02-27 04:43:44 +03:00
|
|
|
|
2004-10-05 14:19:07 +04:00
|
|
|
/*
|
2003-02-27 04:43:44 +03:00
|
|
|
* During sorting phase b points to a member of heap that cannot be
|
|
|
|
* bigger then biggest of vec[0] and vec[1], and cmp(a, b, arg) <= 0
|
|
|
|
* always holds.
|
|
|
|
*/
|
2005-11-16 13:02:57 +03:00
|
|
|
if (building || hi == 2) {
|
|
|
|
CALL_CMP(a, b);
|
|
|
|
if (cmp_result >= 0)
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
2002-03-13 04:50:13 +03:00
|
|
|
|
2003-02-27 04:43:44 +03:00
|
|
|
MEMCPY(pivot, a, elsize);
|
|
|
|
MEMCPY(a, b, elsize);
|
2002-03-13 04:50:13 +03:00
|
|
|
lo = j;
|
|
|
|
} else {
|
|
|
|
a = (char *)vec2 + lo * elsize;
|
2003-02-27 04:43:44 +03:00
|
|
|
MEMCPY(pivot, a, elsize);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
2001-01-04 13:13:18 +03:00
|
|
|
|
2002-03-13 04:50:13 +03:00
|
|
|
hiDiv2 = hi/2;
|
|
|
|
while (lo <= hiDiv2) {
|
|
|
|
j = lo + lo;
|
|
|
|
a = (char *)vec2 + j * elsize;
|
|
|
|
b = (char *)vec + (j - 1) * elsize;
|
2005-11-16 13:02:57 +03:00
|
|
|
if (j < hi) {
|
|
|
|
CALL_CMP(a, b);
|
|
|
|
if (cmp_result < 0)
|
|
|
|
j++;
|
|
|
|
}
|
2002-03-13 04:50:13 +03:00
|
|
|
b = (char *)vec2 + j * elsize;
|
2005-11-16 13:02:57 +03:00
|
|
|
CALL_CMP(pivot, b);
|
|
|
|
if (cmp_result >= 0)
|
2002-03-13 04:50:13 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
a = (char *)vec2 + lo * elsize;
|
2003-02-27 04:43:44 +03:00
|
|
|
MEMCPY(a, b, elsize);
|
2002-03-13 04:50:13 +03:00
|
|
|
lo = j;
|
|
|
|
}
|
|
|
|
|
|
|
|
a = (char *)vec2 + lo * elsize;
|
2003-02-27 04:43:44 +03:00
|
|
|
MEMCPY(a, pivot, elsize);
|
2005-11-16 13:02:57 +03:00
|
|
|
|
|
|
|
return JS_TRUE;
|
|
|
|
|
|
|
|
#undef CALL_CMP
|
2003-02-27 04:43:44 +03:00
|
|
|
#undef MEMCPY
|
2005-11-16 13:02:57 +03:00
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2005-11-16 13:02:57 +03:00
|
|
|
JSBool
|
2005-10-09 10:09:21 +04:00
|
|
|
js_HeapSort(void *vec, size_t nel, void *pivot, size_t elsize,
|
|
|
|
JSComparator cmp, void *arg)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
2003-02-27 04:43:44 +03:00
|
|
|
HSortArgs hsa;
|
|
|
|
size_t i;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2003-02-27 04:43:44 +03:00
|
|
|
hsa.vec = vec;
|
|
|
|
hsa.elsize = elsize;
|
|
|
|
hsa.pivot = pivot;
|
|
|
|
hsa.cmp = cmp;
|
|
|
|
hsa.arg = arg;
|
|
|
|
hsa.fastcopy = (cmp == sort_compare || cmp == sort_compare_strings);
|
|
|
|
|
2005-11-16 13:02:57 +03:00
|
|
|
for (i = nel/2; i != 0; i--) {
|
|
|
|
if (!HeapSortHelper(JS_TRUE, &hsa, i, nel))
|
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
while (nel > 2) {
|
|
|
|
if (!HeapSortHelper(JS_FALSE, &hsa, 1, --nel))
|
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return JS_TRUE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct CompareArgs {
|
2005-09-02 21:49:05 +04:00
|
|
|
JSContext *context;
|
|
|
|
jsval fval;
|
|
|
|
jsval *localroot; /* need one local root, for sort_compare */
|
1998-03-28 05:44:41 +03:00
|
|
|
} CompareArgs;
|
|
|
|
|
2005-11-16 13:02:57 +03:00
|
|
|
static JSBool
|
|
|
|
sort_compare(void *arg, const void *a, const void *b, int *result)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
jsval av = *(const jsval *)a, bv = *(const jsval *)b;
|
2000-02-04 05:01:49 +03:00
|
|
|
CompareArgs *ca = (CompareArgs *) arg;
|
1998-03-28 05:44:41 +03:00
|
|
|
JSContext *cx = ca->context;
|
2006-03-15 23:49:09 +03:00
|
|
|
jsval fval;
|
1998-03-28 05:44:41 +03:00
|
|
|
JSBool ok;
|
|
|
|
|
2006-03-15 23:49:09 +03:00
|
|
|
/**
|
|
|
|
* array_sort deals with holes and undefs on its own and they should not
|
|
|
|
* come here.
|
2005-06-08 20:38:38 +04:00
|
|
|
*/
|
2006-03-15 23:49:09 +03:00
|
|
|
JS_ASSERT(av != JSVAL_HOLE);
|
|
|
|
JS_ASSERT(bv != JSVAL_HOLE);
|
|
|
|
JS_ASSERT(av != JSVAL_VOID);
|
|
|
|
JS_ASSERT(bv != JSVAL_VOID);
|
2005-06-08 20:38:38 +04:00
|
|
|
|
2006-03-15 23:49:09 +03:00
|
|
|
*result = 0;
|
2005-11-16 13:02:57 +03:00
|
|
|
ok = JS_TRUE;
|
2006-03-15 23:49:09 +03:00
|
|
|
fval = ca->fval;
|
|
|
|
if (fval == JSVAL_NULL) {
|
2003-06-12 04:26:40 +04:00
|
|
|
JSString *astr, *bstr;
|
|
|
|
|
2006-03-15 23:49:09 +03:00
|
|
|
if (av != bv) {
|
2005-09-02 21:49:05 +04:00
|
|
|
/*
|
|
|
|
* Set our local root to astr in case the second js_ValueToString
|
|
|
|
* displaces the newborn root in cx, and the GC nests under that
|
|
|
|
* call. Don't bother guarding the local root store with an astr
|
|
|
|
* non-null test. If we tag null as a string, the GC will untag,
|
|
|
|
* null-test, and avoid dereferencing null.
|
|
|
|
*/
|
|
|
|
astr = js_ValueToString(cx, av);
|
|
|
|
*ca->localroot = STRING_TO_JSVAL(astr);
|
|
|
|
if (astr && (bstr = js_ValueToString(cx, bv)))
|
2006-03-15 23:49:09 +03:00
|
|
|
*result = js_CompareStrings(astr, bstr);
|
2005-09-02 21:49:05 +04:00
|
|
|
else
|
2005-11-16 13:02:57 +03:00
|
|
|
ok = JS_FALSE;
|
2003-06-12 04:26:40 +04:00
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
} else {
|
2006-03-15 23:49:09 +03:00
|
|
|
jsdouble cmp;
|
|
|
|
jsval rval, argv[2];
|
|
|
|
|
2003-06-12 04:26:40 +04:00
|
|
|
argv[0] = av;
|
|
|
|
argv[1] = bv;
|
|
|
|
ok = js_InternalCall(cx,
|
|
|
|
OBJ_GET_PARENT(cx, JSVAL_TO_OBJECT(fval)),
|
|
|
|
fval, 2, argv, &rval);
|
|
|
|
if (ok) {
|
|
|
|
ok = js_ValueToNumber(cx, rval, &cmp);
|
2005-09-02 21:49:05 +04:00
|
|
|
|
2003-06-12 04:26:40 +04:00
|
|
|
/* Clamp cmp to -1, 0, 1. */
|
2005-09-02 21:49:05 +04:00
|
|
|
if (ok) {
|
|
|
|
if (JSDOUBLE_IS_NaN(cmp)) {
|
|
|
|
/*
|
|
|
|
* XXX report some kind of error here? ECMA talks about
|
|
|
|
* 'consistent compare functions' that don't return NaN,
|
|
|
|
* but is silent about what the result should be. So we
|
|
|
|
* currently ignore it.
|
|
|
|
*/
|
|
|
|
} else if (cmp != 0) {
|
2006-03-15 23:49:09 +03:00
|
|
|
*result = cmp > 0 ? 1 : -1;
|
2005-09-02 21:49:05 +04:00
|
|
|
}
|
2003-06-12 04:26:40 +04:00
|
|
|
}
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
2005-11-16 13:02:57 +03:00
|
|
|
return ok;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2002-05-27 09:53:57 +04:00
|
|
|
static int
|
2005-11-16 13:02:57 +03:00
|
|
|
sort_compare_strings(void *arg, const void *a, const void *b, int *result)
|
2002-05-27 09:53:57 +04:00
|
|
|
{
|
|
|
|
jsval av = *(const jsval *)a, bv = *(const jsval *)b;
|
|
|
|
|
2005-11-16 13:02:57 +03:00
|
|
|
*result = (int) js_CompareStrings(JSVAL_TO_STRING(av), JSVAL_TO_STRING(bv));
|
|
|
|
return JS_TRUE;
|
2002-05-27 09:53:57 +04:00
|
|
|
}
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
static JSBool
|
|
|
|
array_sort(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
2005-10-12 11:39:45 +04:00
|
|
|
jsval fval, *vec, *pivotroot;
|
1998-03-28 05:44:41 +03:00
|
|
|
CompareArgs ca;
|
2006-03-15 23:49:09 +03:00
|
|
|
jsuint len, newlen, i, undefs;
|
2004-11-30 20:52:29 +03:00
|
|
|
JSStackFrame *fp;
|
1998-04-24 04:31:11 +04:00
|
|
|
jsid id;
|
2005-11-16 13:02:57 +03:00
|
|
|
JSBool ok;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2002-05-27 09:53:57 +04:00
|
|
|
/*
|
|
|
|
* Optimize the default compare function case if all of obj's elements
|
|
|
|
* have values of type string.
|
|
|
|
*/
|
|
|
|
JSBool all_strings;
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
if (argc > 0) {
|
2003-06-12 04:26:40 +04:00
|
|
|
if (JSVAL_IS_PRIMITIVE(argv[0])) {
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
|
|
|
|
JSMSG_BAD_SORT_ARG);
|
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
fval = argv[0];
|
2002-05-27 09:53:57 +04:00
|
|
|
all_strings = JS_FALSE; /* non-default compare function */
|
1998-03-28 05:44:41 +03:00
|
|
|
} else {
|
2003-06-12 04:26:40 +04:00
|
|
|
fval = JSVAL_NULL;
|
2002-05-27 09:53:57 +04:00
|
|
|
all_strings = JS_TRUE; /* check for all string values */
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!js_GetLengthProperty(cx, obj, &len))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
2002-11-07 13:51:23 +03:00
|
|
|
if (len == 0) {
|
|
|
|
*rval = OBJECT_TO_JSVAL(obj);
|
2000-06-03 23:00:28 +04:00
|
|
|
return JS_TRUE;
|
2002-11-07 13:51:23 +03:00
|
|
|
}
|
2002-08-01 01:42:12 +04:00
|
|
|
|
2005-10-09 10:09:21 +04:00
|
|
|
/*
|
2005-10-12 11:39:45 +04:00
|
|
|
* We need a temporary array of len jsvals to hold elements of the array.
|
|
|
|
* Check that its size does not overflow size_t, which would allow for
|
|
|
|
* indexing beyond the end of the malloc'd vector.
|
2005-10-09 10:09:21 +04:00
|
|
|
*/
|
2005-10-12 11:39:45 +04:00
|
|
|
if (len > ((size_t) -1) / sizeof(jsval)) {
|
2002-08-01 01:42:12 +04:00
|
|
|
JS_ReportOutOfMemory(cx);
|
|
|
|
return JS_FALSE;
|
|
|
|
}
|
2005-10-12 11:39:45 +04:00
|
|
|
|
2006-03-18 01:09:46 +03:00
|
|
|
vec = (jsval *) JS_malloc(cx, ((size_t) len) * sizeof(jsval));
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!vec)
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2006-03-18 01:09:46 +03:00
|
|
|
/*
|
|
|
|
* Initialize vec as a root. We will clear elements of vec one by
|
|
|
|
* one while increasing fp->nvars when we know that the property at
|
|
|
|
* the corresponding index exists and its value must be rooted.
|
|
|
|
*
|
|
|
|
* In this way when sorting a huge mostly spare array we will not
|
|
|
|
* access the tail of vec corresponding to properties that do not
|
|
|
|
* exist allowing OS to avoiding committing RAM for it. See bug 330812.
|
|
|
|
*/
|
2004-11-30 20:52:29 +03:00
|
|
|
fp = cx->fp;
|
|
|
|
fp->vars = vec;
|
2006-03-18 01:09:46 +03:00
|
|
|
fp->nvars = 0;
|
2004-11-30 20:52:29 +03:00
|
|
|
|
2006-03-15 23:49:09 +03:00
|
|
|
/*
|
2006-03-16 11:04:28 +03:00
|
|
|
* By ECMA 262, 15.4.4.11, a property that does not exist (which we
|
|
|
|
* call a "hole") is always greater than an existing property with
|
|
|
|
* value undefined and that is always greater than any other property.
|
|
|
|
* Thus to sort holes and undefs we simply count them, sort the rest
|
|
|
|
* of elements, append undefs after them and then make holes after
|
|
|
|
* undefs.
|
2006-03-15 23:49:09 +03:00
|
|
|
*/
|
|
|
|
undefs = 0;
|
2005-10-12 11:39:45 +04:00
|
|
|
newlen = 0;
|
1998-04-24 04:31:11 +04:00
|
|
|
for (i = 0; i < len; i++) {
|
2005-11-16 13:02:57 +03:00
|
|
|
ok = IndexToExistingId(cx, obj, i, &id);
|
|
|
|
if (!ok)
|
2003-06-12 04:26:40 +04:00
|
|
|
goto out;
|
2005-07-13 20:38:46 +04:00
|
|
|
|
2006-03-15 23:49:09 +03:00
|
|
|
if (id == JSID_HOLE)
|
2005-07-13 20:38:46 +04:00
|
|
|
continue;
|
2005-06-08 20:38:38 +04:00
|
|
|
|
2006-03-18 01:09:46 +03:00
|
|
|
/* Clear vec[newlen] before including it in the rooted set. */
|
|
|
|
vec[newlen] = JSVAL_NULL;
|
|
|
|
fp->nvars = newlen + 1;
|
2006-03-15 23:49:09 +03:00
|
|
|
ok = OBJ_GET_PROPERTY(cx, obj, id, &vec[newlen]);
|
2005-11-16 13:02:57 +03:00
|
|
|
if (!ok)
|
2003-06-12 04:26:40 +04:00
|
|
|
goto out;
|
2002-05-27 09:53:57 +04:00
|
|
|
|
2006-03-15 23:49:09 +03:00
|
|
|
if (vec[newlen] == JSVAL_VOID) {
|
|
|
|
++undefs;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2002-05-27 09:53:57 +04:00
|
|
|
/* We know JSVAL_IS_STRING yields 0 or 1, so avoid a branch via &=. */
|
2006-03-15 23:49:09 +03:00
|
|
|
all_strings &= JSVAL_IS_STRING(vec[newlen]);
|
|
|
|
|
|
|
|
++newlen;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2006-03-15 23:49:09 +03:00
|
|
|
/* Here len == newlen + undefs + number_of_holes. */
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
ca.context = cx;
|
|
|
|
ca.fval = fval;
|
2005-10-12 11:39:45 +04:00
|
|
|
ca.localroot = argv + argc; /* local GC root for temporary string */
|
|
|
|
pivotroot = argv + argc + 1; /* local GC root for pivot val */
|
2006-03-19 02:36:04 +03:00
|
|
|
ok = js_HeapSort(vec, (size_t) newlen, pivotroot, sizeof(jsval),
|
2005-11-16 13:02:57 +03:00
|
|
|
all_strings ? sort_compare_strings : sort_compare,
|
|
|
|
&ca);
|
|
|
|
|
|
|
|
if (ok) {
|
2006-03-15 23:49:09 +03:00
|
|
|
while (undefs != 0) {
|
|
|
|
--undefs;
|
|
|
|
vec[newlen++] = JSVAL_VOID;
|
|
|
|
}
|
2005-11-16 13:02:57 +03:00
|
|
|
ok = InitArrayElements(cx, obj, newlen, vec);
|
|
|
|
if (ok)
|
2003-06-12 04:26:40 +04:00
|
|
|
*rval = OBJECT_TO_JSVAL(obj);
|
2005-06-08 22:08:53 +04:00
|
|
|
|
|
|
|
/* Re-create any holes that sorted to the end of the array. */
|
|
|
|
while (len > newlen) {
|
|
|
|
jsval junk;
|
|
|
|
|
|
|
|
if (!IndexToId(cx, --len, &id))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!OBJ_DELETE_PROPERTY(cx, obj, id, &junk))
|
|
|
|
return JS_FALSE;
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
1999-04-27 19:18:57 +04:00
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
out:
|
1998-04-24 04:31:11 +04:00
|
|
|
if (vec)
|
2003-06-12 04:26:40 +04:00
|
|
|
JS_free(cx, vec);
|
2005-11-16 13:02:57 +03:00
|
|
|
return ok;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2003-06-12 04:26:40 +04:00
|
|
|
* Perl-inspired push, pop, shift, unshift, and splice methods.
|
1998-03-28 05:44:41 +03:00
|
|
|
*/
|
|
|
|
static JSBool
|
|
|
|
array_push(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
jsuint length;
|
1998-03-28 05:44:41 +03:00
|
|
|
uintN i;
|
1998-04-24 04:31:11 +04:00
|
|
|
jsid id;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!js_GetLengthProperty(cx, obj, &length))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
for (i = 0; i < argc; i++) {
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!IndexToId(cx, length + i, &id))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!OBJ_SET_PROPERTY(cx, obj, id, &argv[i]))
|
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2006-04-27 01:33:01 +04:00
|
|
|
/* Per ECMA-262, return the new array length. */
|
1998-03-28 05:44:41 +03:00
|
|
|
length += argc;
|
2006-04-27 01:33:01 +04:00
|
|
|
if (!IndexToValue(cx, length, rval))
|
|
|
|
return JS_FALSE;
|
1998-04-24 04:31:11 +04:00
|
|
|
return js_SetLengthProperty(cx, obj, length);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_pop(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
jsuint index;
|
|
|
|
jsid id;
|
|
|
|
jsval junk;
|
|
|
|
|
|
|
|
if (!js_GetLengthProperty(cx, obj, &index))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-04-24 04:31:11 +04:00
|
|
|
if (index > 0) {
|
2003-06-12 04:26:40 +04:00
|
|
|
index--;
|
|
|
|
if (!IndexToId(cx, index, &id))
|
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2003-06-12 04:26:40 +04:00
|
|
|
/* Get the to-be-deleted property's value into rval. */
|
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, rval))
|
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!OBJ_DELETE_PROPERTY(cx, obj, id, &junk))
|
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
1998-04-24 04:31:11 +04:00
|
|
|
return js_SetLengthProperty(cx, obj, index);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_shift(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
jsuint length, i;
|
|
|
|
jsid id, id2;
|
2005-11-01 04:13:36 +03:00
|
|
|
jsval junk;
|
1998-04-24 04:31:11 +04:00
|
|
|
|
|
|
|
if (!js_GetLengthProperty(cx, obj, &length))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-04-24 04:31:11 +04:00
|
|
|
if (length > 0) {
|
2003-06-12 04:26:40 +04:00
|
|
|
length--;
|
|
|
|
id = JSVAL_ZERO;
|
|
|
|
|
|
|
|
/* Get the to-be-deleted property's value into rval ASAP. */
|
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, rval))
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Slide down the array above the first element.
|
|
|
|
*/
|
|
|
|
if (length > 0) {
|
|
|
|
for (i = 1; i <= length; i++) {
|
|
|
|
if (!IndexToId(cx, i, &id))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!IndexToId(cx, i - 1, &id2))
|
|
|
|
return JS_FALSE;
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, &argv[0]))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_SET_PROPERTY(cx, obj, id2, &argv[0]))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Delete the only or last element. */
|
|
|
|
if (!OBJ_DELETE_PROPERTY(cx, obj, id, &junk))
|
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
1998-04-24 04:31:11 +04:00
|
|
|
return js_SetLengthProperty(cx, obj, length);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_unshift(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
2003-06-12 04:26:40 +04:00
|
|
|
jsval *rval)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
jsuint length, last;
|
1998-03-28 05:44:41 +03:00
|
|
|
uintN i;
|
1998-04-24 04:31:11 +04:00
|
|
|
jsid id, id2;
|
2005-11-01 04:13:36 +03:00
|
|
|
jsval *vp, junk;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!js_GetLengthProperty(cx, obj, &length))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
if (argc > 0) {
|
2003-06-12 04:26:40 +04:00
|
|
|
/* Slide up the array to make room for argc at the bottom. */
|
|
|
|
if (length > 0) {
|
|
|
|
last = length;
|
2005-11-01 04:13:36 +03:00
|
|
|
vp = argv + argc;
|
2003-06-12 04:26:40 +04:00
|
|
|
while (last--) {
|
2005-10-02 10:27:07 +04:00
|
|
|
if (!IndexToExistingId(cx, obj, last, &id))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
2005-11-08 23:58:28 +03:00
|
|
|
if (!IndexToId(cx, last + argc, &id2))
|
|
|
|
return JS_FALSE;
|
2005-10-02 10:27:07 +04:00
|
|
|
if (id == JSID_HOLE) {
|
2005-11-01 04:13:36 +03:00
|
|
|
OBJ_DELETE_PROPERTY(cx, obj, id2, &junk);
|
1999-04-27 19:18:57 +04:00
|
|
|
continue;
|
|
|
|
}
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, vp))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_SET_PROPERTY(cx, obj, id2, vp))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Copy from argv to the bottom of the array. */
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
if (!IndexToId(cx, i, &id))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!OBJ_SET_PROPERTY(cx, obj, id, &argv[i]))
|
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Follow Perl by returning the new array length. */
|
|
|
|
length += argc;
|
|
|
|
if (!js_SetLengthProperty(cx, obj, length))
|
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
1998-04-24 04:31:11 +04:00
|
|
|
return IndexToValue(cx, length, rval);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_splice(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
2005-11-01 04:13:36 +03:00
|
|
|
jsval *vp, junk;
|
1998-04-24 04:31:11 +04:00
|
|
|
jsuint length, begin, end, count, delta, last;
|
1998-03-28 05:44:41 +03:00
|
|
|
jsdouble d;
|
1998-04-24 04:31:11 +04:00
|
|
|
jsid id, id2;
|
1998-03-28 05:44:41 +03:00
|
|
|
JSObject *obj2;
|
2005-11-01 04:13:36 +03:00
|
|
|
uintN i;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2005-11-01 04:13:36 +03:00
|
|
|
/*
|
|
|
|
* Nothing to do if no args. Otherwise point vp at our one explicit local
|
|
|
|
* root and get length.
|
|
|
|
*/
|
1998-03-28 05:44:41 +03:00
|
|
|
if (argc == 0)
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_TRUE;
|
2005-11-01 04:13:36 +03:00
|
|
|
vp = argv + argc;
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!js_GetLengthProperty(cx, obj, &length))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
|
|
|
/* Convert the first argument into a starting index. */
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!js_ValueToNumber(cx, *argv, &d))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-04-24 04:31:11 +04:00
|
|
|
d = js_DoubleToInteger(d);
|
|
|
|
if (d < 0) {
|
2003-06-12 04:26:40 +04:00
|
|
|
d += length;
|
|
|
|
if (d < 0)
|
|
|
|
d = 0;
|
1998-04-24 04:31:11 +04:00
|
|
|
} else if (d > length) {
|
2003-06-12 04:26:40 +04:00
|
|
|
d = length;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
1998-04-24 04:31:11 +04:00
|
|
|
begin = (jsuint)d; /* d has been clamped to uint32 */
|
1998-03-28 05:44:41 +03:00
|
|
|
argc--;
|
|
|
|
argv++;
|
|
|
|
|
|
|
|
/* Convert the second argument from a count into a fencepost index. */
|
|
|
|
delta = length - begin;
|
|
|
|
if (argc == 0) {
|
2003-06-12 04:26:40 +04:00
|
|
|
count = delta;
|
|
|
|
end = length;
|
1998-03-28 05:44:41 +03:00
|
|
|
} else {
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!js_ValueToNumber(cx, *argv, &d))
|
|
|
|
return JS_FALSE;
|
|
|
|
d = js_DoubleToInteger(d);
|
|
|
|
if (d < 0)
|
|
|
|
d = 0;
|
|
|
|
else if (d > delta)
|
|
|
|
d = delta;
|
|
|
|
count = (jsuint)d;
|
|
|
|
end = begin + count;
|
|
|
|
argc--;
|
|
|
|
argv++;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2005-07-13 20:38:46 +04:00
|
|
|
|
2006-04-28 04:20:44 +04:00
|
|
|
/*
|
|
|
|
* Create a new array value to return. Our ECMA v2 proposal specs
|
|
|
|
* that splice always returns an array value, even when given no
|
|
|
|
* arguments. We think this is best because it eliminates the need
|
|
|
|
* for callers to do an extra test to handle the empty splice case.
|
|
|
|
*/
|
|
|
|
obj2 = js_NewArrayObject(cx, 0, NULL);
|
|
|
|
if (!obj2)
|
|
|
|
return JS_FALSE;
|
|
|
|
*rval = OBJECT_TO_JSVAL(obj2);
|
2006-04-27 01:33:01 +04:00
|
|
|
|
2006-04-28 04:20:44 +04:00
|
|
|
/* If there are elements to remove, put them into the return value. */
|
|
|
|
if (count > 0) {
|
|
|
|
for (last = begin; last < end; last++) {
|
|
|
|
if (!IndexToExistingId(cx, obj, last, &id))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (id == JSID_HOLE)
|
|
|
|
continue; /* don't fill holes in the new array */
|
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, vp))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!IndexToId(cx, last - begin, &id2))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!OBJ_SET_PROPERTY(cx, obj2, id2, vp))
|
2006-04-27 01:33:01 +04:00
|
|
|
return JS_FALSE;
|
2003-06-12 04:26:40 +04:00
|
|
|
}
|
2006-04-28 04:20:44 +04:00
|
|
|
|
|
|
|
if (!js_SetLengthProperty(cx, obj2, end - begin))
|
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Find the direction (up or down) to copy and make way for argv. */
|
1998-04-24 04:31:11 +04:00
|
|
|
if (argc > count) {
|
2003-06-12 04:26:40 +04:00
|
|
|
delta = (jsuint)argc - count;
|
|
|
|
last = length;
|
|
|
|
/* (uint) end could be 0, so can't use vanilla >= test */
|
|
|
|
while (last-- > end) {
|
2005-10-02 10:27:07 +04:00
|
|
|
if (!IndexToExistingId(cx, obj, last, &id))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
if (!IndexToId(cx, last + delta, &id2))
|
|
|
|
return JS_FALSE;
|
2005-10-02 10:27:07 +04:00
|
|
|
if (id != JSID_HOLE) {
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, vp))
|
2005-07-13 20:38:46 +04:00
|
|
|
return JS_FALSE;
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_SET_PROPERTY(cx, obj, id2, vp))
|
2005-07-13 20:38:46 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
} else {
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_DELETE_PROPERTY(cx, obj, id2, &junk))
|
2005-07-13 20:38:46 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
2003-06-12 04:26:40 +04:00
|
|
|
}
|
|
|
|
length += delta;
|
1998-04-24 04:31:11 +04:00
|
|
|
} else if (argc < count) {
|
2003-06-12 04:26:40 +04:00
|
|
|
delta = count - (jsuint)argc;
|
|
|
|
for (last = end; last < length; last++) {
|
2005-10-02 10:27:07 +04:00
|
|
|
if (!IndexToExistingId(cx, obj, last, &id))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
if (!IndexToId(cx, last - delta, &id2))
|
|
|
|
return JS_FALSE;
|
2005-10-02 10:27:07 +04:00
|
|
|
if (id != JSID_HOLE) {
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, vp))
|
2005-07-13 20:38:46 +04:00
|
|
|
return JS_FALSE;
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_SET_PROPERTY(cx, obj, id2, vp))
|
2005-07-13 20:38:46 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
} else {
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_DELETE_PROPERTY(cx, obj, id2, &junk))
|
2005-07-13 20:38:46 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
2003-06-12 04:26:40 +04:00
|
|
|
}
|
|
|
|
length -= delta;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Copy from argv into the hole to complete the splice. */
|
|
|
|
for (i = 0; i < argc; i++) {
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!IndexToId(cx, begin + i, &id))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!OBJ_SET_PROPERTY(cx, obj, id, &argv[i]))
|
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Update length in case we deleted elements from the end. */
|
1998-04-24 04:31:11 +04:00
|
|
|
return js_SetLengthProperty(cx, obj, length);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Python-esque sequence operations.
|
|
|
|
*/
|
|
|
|
static JSBool
|
|
|
|
array_concat(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
2005-11-01 04:13:36 +03:00
|
|
|
jsval *vp, v;
|
1998-03-28 05:44:41 +03:00
|
|
|
JSObject *nobj, *aobj;
|
2002-09-20 22:45:05 +04:00
|
|
|
jsuint length, alength, slot;
|
1998-03-28 05:44:41 +03:00
|
|
|
uintN i;
|
2002-09-20 22:45:05 +04:00
|
|
|
jsid id, id2;
|
|
|
|
|
2005-11-01 04:13:36 +03:00
|
|
|
/* Hoist the explicit local root address computation. */
|
|
|
|
vp = argv + argc;
|
|
|
|
|
2002-09-20 22:45:05 +04:00
|
|
|
/* Treat obj as the first argument; see ECMA 15.4.4.4. */
|
|
|
|
--argv;
|
|
|
|
JS_ASSERT(obj == JSVAL_TO_OBJECT(argv[0]));
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2002-09-20 22:45:05 +04:00
|
|
|
/* Create a new Array object and store it in the rval local root. */
|
1998-04-24 04:31:11 +04:00
|
|
|
nobj = js_NewArrayObject(cx, 0, NULL);
|
1998-03-28 05:44:41 +03:00
|
|
|
if (!nobj)
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
2002-09-20 22:45:05 +04:00
|
|
|
*rval = OBJECT_TO_JSVAL(nobj);
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2002-09-20 22:45:05 +04:00
|
|
|
/* Loop over [0, argc] to concat args into nobj, expanding all Arrays. */
|
|
|
|
length = 0;
|
|
|
|
for (i = 0; i <= argc; i++) {
|
2003-06-12 04:26:40 +04:00
|
|
|
v = argv[i];
|
|
|
|
if (JSVAL_IS_OBJECT(v)) {
|
|
|
|
aobj = JSVAL_TO_OBJECT(v);
|
|
|
|
if (aobj && OBJ_GET_CLASS(cx, aobj) == &js_ArrayClass) {
|
2002-09-20 22:45:05 +04:00
|
|
|
if (!OBJ_GET_PROPERTY(cx, aobj,
|
2004-10-05 14:19:07 +04:00
|
|
|
ATOM_TO_JSID(cx->runtime->atomState
|
|
|
|
.lengthAtom),
|
2005-11-01 04:13:36 +03:00
|
|
|
vp)) {
|
2002-09-20 22:45:05 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!ValueIsLength(cx, *vp, &alength))
|
2002-09-20 22:45:05 +04:00
|
|
|
return JS_FALSE;
|
2003-06-12 04:26:40 +04:00
|
|
|
for (slot = 0; slot < alength; slot++) {
|
2005-10-02 10:27:07 +04:00
|
|
|
if (!IndexToExistingId(cx, aobj, slot, &id))
|
2005-07-06 01:25:12 +04:00
|
|
|
return JS_FALSE;
|
2005-10-02 10:27:07 +04:00
|
|
|
if (id == JSID_HOLE) {
|
|
|
|
/*
|
2005-07-06 01:25:12 +04:00
|
|
|
* Per ECMA 262, 15.4.4.4, step 9, ignore non-existent
|
|
|
|
* properties.
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_GET_PROPERTY(cx, aobj, id, vp))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
2005-10-02 10:27:07 +04:00
|
|
|
if (!IndexToId(cx, length + slot, &id2))
|
|
|
|
return JS_FALSE;
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_SET_PROPERTY(cx, nobj, id2, vp))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
length += alength;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-01 04:13:36 +03:00
|
|
|
*vp = v;
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!IndexToId(cx, length, &id))
|
|
|
|
return JS_FALSE;
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_SET_PROPERTY(cx, nobj, id, vp))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
length++;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2005-07-06 01:25:12 +04:00
|
|
|
return js_SetLengthProperty(cx, nobj, length);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_slice(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
2005-11-01 04:13:36 +03:00
|
|
|
jsval *vp;
|
1998-03-28 05:44:41 +03:00
|
|
|
JSObject *nobj;
|
1998-04-24 04:31:11 +04:00
|
|
|
jsuint length, begin, end, slot;
|
1998-03-28 05:44:41 +03:00
|
|
|
jsdouble d;
|
1998-04-24 04:31:11 +04:00
|
|
|
jsid id, id2;
|
2005-11-01 04:13:36 +03:00
|
|
|
|
|
|
|
/* Hoist the explicit local root address computation. */
|
|
|
|
vp = argv + argc;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2005-10-11 03:33:16 +04:00
|
|
|
/* Create a new Array object and store it in the rval local root. */
|
1998-04-24 04:31:11 +04:00
|
|
|
nobj = js_NewArrayObject(cx, 0, NULL);
|
1998-03-28 05:44:41 +03:00
|
|
|
if (!nobj)
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
2005-10-11 03:33:16 +04:00
|
|
|
*rval = OBJECT_TO_JSVAL(nobj);
|
1998-03-28 05:44:41 +03:00
|
|
|
|
1998-04-24 04:31:11 +04:00
|
|
|
if (!js_GetLengthProperty(cx, obj, &length))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
begin = 0;
|
|
|
|
end = length;
|
|
|
|
|
|
|
|
if (argc > 0) {
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!js_ValueToNumber(cx, argv[0], &d))
|
|
|
|
return JS_FALSE;
|
|
|
|
d = js_DoubleToInteger(d);
|
|
|
|
if (d < 0) {
|
|
|
|
d += length;
|
|
|
|
if (d < 0)
|
|
|
|
d = 0;
|
|
|
|
} else if (d > length) {
|
|
|
|
d = length;
|
|
|
|
}
|
|
|
|
begin = (jsuint)d;
|
|
|
|
|
|
|
|
if (argc > 1) {
|
|
|
|
if (!js_ValueToNumber(cx, argv[1], &d))
|
|
|
|
return JS_FALSE;
|
|
|
|
d = js_DoubleToInteger(d);
|
|
|
|
if (d < 0) {
|
|
|
|
d += length;
|
|
|
|
if (d < 0)
|
|
|
|
d = 0;
|
|
|
|
} else if (d > length) {
|
|
|
|
d = length;
|
|
|
|
}
|
|
|
|
end = (jsuint)d;
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2005-07-18 22:44:22 +04:00
|
|
|
if (begin > end)
|
|
|
|
begin = end;
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
for (slot = begin; slot < end; slot++) {
|
2005-10-02 10:27:07 +04:00
|
|
|
if (!IndexToExistingId(cx, obj, slot, &id))
|
2005-07-13 20:38:46 +04:00
|
|
|
return JS_FALSE;
|
2005-10-02 10:27:07 +04:00
|
|
|
if (id == JSID_HOLE)
|
2005-07-13 20:38:46 +04:00
|
|
|
continue;
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, vp))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
2005-10-02 10:27:07 +04:00
|
|
|
if (!IndexToId(cx, slot - begin, &id2))
|
|
|
|
return JS_FALSE;
|
2005-11-01 04:13:36 +03:00
|
|
|
if (!OBJ_SET_PROPERTY(cx, nobj, id2, vp))
|
2003-06-12 04:26:40 +04:00
|
|
|
return JS_FALSE;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
2005-07-13 20:38:46 +04:00
|
|
|
return js_SetLengthProperty(cx, nobj, end - begin);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
2005-04-17 22:31:59 +04:00
|
|
|
#if JS_HAS_ARRAY_EXTRAS
|
2005-10-02 10:27:07 +04:00
|
|
|
|
2005-04-17 22:31:59 +04:00
|
|
|
static JSBool
|
2005-10-02 10:27:07 +04:00
|
|
|
array_indexOfHelper(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
|
|
jsval *rval, JSBool isLast)
|
2005-04-17 22:31:59 +04:00
|
|
|
{
|
2005-10-02 10:27:07 +04:00
|
|
|
jsuint length, i, stop;
|
|
|
|
jsint direction;
|
2005-05-04 06:43:13 +04:00
|
|
|
|
|
|
|
if (!js_GetLengthProperty(cx, obj, &length))
|
2005-04-17 22:31:59 +04:00
|
|
|
return JS_FALSE;
|
2005-10-02 10:27:07 +04:00
|
|
|
if (length == 0)
|
|
|
|
goto not_found;
|
|
|
|
|
|
|
|
if (argc <= 1) {
|
|
|
|
i = isLast ? length - 1 : 0;
|
|
|
|
} else {
|
|
|
|
jsdouble start;
|
|
|
|
|
2005-05-04 06:43:13 +04:00
|
|
|
if (!js_ValueToNumber(cx, argv[1], &start))
|
|
|
|
return JS_FALSE;
|
|
|
|
start = js_DoubleToInteger(start);
|
|
|
|
if (start < 0) {
|
|
|
|
start += length;
|
2005-10-02 10:27:07 +04:00
|
|
|
i = (start < 0) ? 0 : (jsuint)start;
|
|
|
|
} else if (start >= length) {
|
|
|
|
i = length - 1;
|
|
|
|
} else {
|
|
|
|
i = (jsuint)start;
|
2005-05-04 06:43:13 +04:00
|
|
|
}
|
|
|
|
}
|
2005-10-02 10:27:07 +04:00
|
|
|
|
|
|
|
if (isLast) {
|
|
|
|
stop = 0;
|
|
|
|
direction = -1;
|
|
|
|
} else {
|
|
|
|
stop = length - 1;
|
|
|
|
direction = 1;
|
|
|
|
}
|
|
|
|
|
2005-10-09 10:09:21 +04:00
|
|
|
for (;;) {
|
2005-04-17 22:31:59 +04:00
|
|
|
jsid id;
|
|
|
|
jsval v;
|
|
|
|
|
2005-10-02 10:27:07 +04:00
|
|
|
if (!IndexToExistingId(cx, obj, (jsuint)i, &id))
|
2005-04-17 22:31:59 +04:00
|
|
|
return JS_FALSE;
|
2005-10-09 10:09:21 +04:00
|
|
|
if (id != JSID_HOLE) {
|
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, &v))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (js_StrictlyEqual(v, argv[0]))
|
|
|
|
return js_NewNumberValue(cx, i, rval);
|
|
|
|
}
|
2005-10-02 10:27:07 +04:00
|
|
|
|
|
|
|
if (i == stop)
|
|
|
|
goto not_found;
|
2005-10-09 10:09:21 +04:00
|
|
|
i += direction;
|
2005-04-17 22:31:59 +04:00
|
|
|
}
|
|
|
|
|
2005-10-02 10:27:07 +04:00
|
|
|
not_found:
|
|
|
|
*rval = INT_TO_JSVAL(-1);
|
2005-05-04 06:43:13 +04:00
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
2005-10-02 10:27:07 +04:00
|
|
|
static JSBool
|
|
|
|
array_indexOf(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
|
|
jsval *rval)
|
|
|
|
{
|
|
|
|
return array_indexOfHelper(cx, obj, argc, argv, rval, JS_FALSE);
|
|
|
|
}
|
|
|
|
|
2005-05-04 06:43:13 +04:00
|
|
|
static JSBool
|
|
|
|
array_lastIndexOf(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
|
|
jsval *rval)
|
|
|
|
{
|
2005-10-02 10:27:07 +04:00
|
|
|
return array_indexOfHelper(cx, obj, argc, argv, rval, JS_TRUE);
|
2005-04-17 22:31:59 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Order is important; extras that use a caller's predicate must follow MAP. */
|
|
|
|
typedef enum ArrayExtraMode {
|
|
|
|
FOREACH,
|
|
|
|
MAP,
|
|
|
|
FILTER,
|
|
|
|
SOME,
|
|
|
|
EVERY
|
|
|
|
} ArrayExtraMode;
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_extra(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval,
|
|
|
|
ArrayExtraMode mode)
|
|
|
|
{
|
2005-11-01 04:13:36 +03:00
|
|
|
jsval *vp, *sp, *origsp, *oldsp;
|
2005-05-04 06:43:13 +04:00
|
|
|
jsuint length, newlen, i;
|
2005-10-25 12:00:30 +04:00
|
|
|
JSObject *callable, *thisp, *newarr;
|
2005-04-17 22:31:59 +04:00
|
|
|
void *mark;
|
|
|
|
JSStackFrame *fp;
|
2006-04-27 04:39:43 +04:00
|
|
|
JSBool ok, cond;
|
2005-10-02 10:27:07 +04:00
|
|
|
|
2005-11-01 04:13:36 +03:00
|
|
|
/* Hoist the explicit local root address computation. */
|
|
|
|
vp = argv + argc;
|
|
|
|
|
2005-05-04 06:43:13 +04:00
|
|
|
if (!js_GetLengthProperty(cx, obj, &length))
|
2005-04-17 22:31:59 +04:00
|
|
|
return JS_FALSE;
|
|
|
|
|
2005-05-04 06:43:13 +04:00
|
|
|
/*
|
2005-10-25 12:00:30 +04:00
|
|
|
* First, get or compute our callee, so that we error out consistently
|
|
|
|
* when passed a non-callable object.
|
2005-05-04 06:43:13 +04:00
|
|
|
*/
|
2005-10-25 12:00:30 +04:00
|
|
|
callable = js_ValueToCallableObject(cx, &argv[0], 0);
|
|
|
|
if (!callable)
|
|
|
|
return JS_FALSE;
|
2005-04-17 22:31:59 +04:00
|
|
|
|
2005-05-04 06:43:13 +04:00
|
|
|
/*
|
|
|
|
* Set our initial return condition, used for zero-length array cases
|
|
|
|
* (and pre-size our map return to match our known length, for all cases).
|
|
|
|
*/
|
2005-11-01 04:13:36 +03:00
|
|
|
#ifdef __GNUC__ /* quell GCC overwarning */
|
|
|
|
newlen = 0;
|
|
|
|
newarr = NULL;
|
|
|
|
ok = JS_TRUE;
|
|
|
|
#endif
|
2005-05-04 06:43:13 +04:00
|
|
|
switch (mode) {
|
|
|
|
case MAP:
|
|
|
|
case FILTER:
|
|
|
|
newlen = (mode == MAP) ? length : 0;
|
|
|
|
newarr = js_NewArrayObject(cx, newlen, NULL);
|
|
|
|
if (!newarr)
|
|
|
|
return JS_FALSE;
|
|
|
|
*rval = OBJECT_TO_JSVAL(newarr);
|
|
|
|
break;
|
|
|
|
case SOME:
|
|
|
|
*rval = JSVAL_FALSE;
|
|
|
|
break;
|
2005-08-19 05:48:48 +04:00
|
|
|
case EVERY:
|
|
|
|
*rval = JSVAL_TRUE;
|
|
|
|
break;
|
2005-05-04 06:43:13 +04:00
|
|
|
case FOREACH:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (length == 0)
|
|
|
|
return JS_TRUE;
|
2005-10-02 10:27:07 +04:00
|
|
|
|
2005-04-17 22:31:59 +04:00
|
|
|
if (argc > 1) {
|
|
|
|
if (!js_ValueToObject(cx, argv[1], &thisp))
|
|
|
|
return JS_FALSE;
|
|
|
|
argv[1] = OBJECT_TO_JSVAL(thisp);
|
|
|
|
} else {
|
2006-05-04 10:46:27 +04:00
|
|
|
thisp = NULL;
|
2005-04-17 22:31:59 +04:00
|
|
|
}
|
|
|
|
|
2005-05-04 06:43:13 +04:00
|
|
|
/* We call with 3 args (value, index, array), plus room for rval. */
|
|
|
|
origsp = js_AllocStack(cx, 2 + 3 + 1, &mark);
|
2005-04-17 22:31:59 +04:00
|
|
|
if (!origsp)
|
|
|
|
return JS_FALSE;
|
2006-05-04 10:46:27 +04:00
|
|
|
origsp[0] = OBJECT_TO_JSVAL(callable);
|
|
|
|
origsp[1] = OBJECT_TO_JSVAL(thisp);
|
|
|
|
|
|
|
|
thisp = js_SafeComputeThis(cx, thisp, origsp + 2);
|
|
|
|
if (!thisp) {
|
|
|
|
ok = JS_FALSE;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 22:31:59 +04:00
|
|
|
|
|
|
|
/* Lift current frame to include our args. */
|
|
|
|
fp = cx->fp;
|
|
|
|
oldsp = fp->sp;
|
|
|
|
|
2005-05-04 06:43:13 +04:00
|
|
|
for (i = 0; i < length; i++) {
|
2005-04-17 22:31:59 +04:00
|
|
|
jsid id;
|
2005-11-01 04:13:36 +03:00
|
|
|
jsval rval2;
|
2005-04-17 22:31:59 +04:00
|
|
|
|
2005-10-02 10:27:07 +04:00
|
|
|
ok = IndexToExistingId(cx, obj, i, &id);
|
2005-04-17 22:31:59 +04:00
|
|
|
if (!ok)
|
|
|
|
break;
|
2005-10-02 10:27:07 +04:00
|
|
|
if (id == JSID_HOLE)
|
|
|
|
continue;
|
2005-11-01 04:13:36 +03:00
|
|
|
ok = OBJ_GET_PROPERTY(cx, obj, id, vp);
|
2005-04-17 22:31:59 +04:00
|
|
|
if (!ok)
|
|
|
|
break;
|
|
|
|
|
2006-05-04 10:46:27 +04:00
|
|
|
/*
|
|
|
|
* Push callable and 'this', then args. We must do this for every
|
|
|
|
* iteration around the loop since js_Invoke uses origsp[0] for rval
|
|
|
|
* storage and some native functions use origsp[1] for local rooting.
|
|
|
|
*/
|
2005-04-17 22:31:59 +04:00
|
|
|
sp = origsp;
|
2005-10-25 12:00:30 +04:00
|
|
|
*sp++ = OBJECT_TO_JSVAL(callable);
|
2005-04-17 22:31:59 +04:00
|
|
|
*sp++ = OBJECT_TO_JSVAL(thisp);
|
2005-11-01 04:13:36 +03:00
|
|
|
*sp++ = *vp;
|
2005-04-17 22:31:59 +04:00
|
|
|
*sp++ = INT_TO_JSVAL(i);
|
2005-05-04 06:43:13 +04:00
|
|
|
*sp++ = OBJECT_TO_JSVAL(obj);
|
2005-04-17 22:31:59 +04:00
|
|
|
|
|
|
|
/* Do the call. */
|
|
|
|
fp->sp = sp;
|
2005-05-04 06:43:13 +04:00
|
|
|
ok = js_Invoke(cx, 3, JSINVOKE_INTERNAL);
|
2005-04-17 22:31:59 +04:00
|
|
|
rval2 = fp->sp[-1];
|
|
|
|
fp->sp = oldsp;
|
|
|
|
if (!ok)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (mode > MAP) {
|
|
|
|
if (rval2 == JSVAL_NULL) {
|
2006-04-27 04:39:43 +04:00
|
|
|
cond = JS_FALSE;
|
2005-04-17 22:31:59 +04:00
|
|
|
} else if (JSVAL_IS_BOOLEAN(rval2)) {
|
2006-04-27 04:39:43 +04:00
|
|
|
cond = JSVAL_TO_BOOLEAN(rval2);
|
2005-04-17 22:31:59 +04:00
|
|
|
} else {
|
2006-04-27 04:39:43 +04:00
|
|
|
ok = js_ValueToBoolean(cx, rval2, &cond);
|
2005-04-17 22:31:59 +04:00
|
|
|
if (!ok)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
case FOREACH:
|
|
|
|
break;
|
|
|
|
case MAP:
|
|
|
|
ok = OBJ_SET_PROPERTY(cx, newarr, id, &rval2);
|
|
|
|
if (!ok)
|
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
case FILTER:
|
2006-04-27 04:39:43 +04:00
|
|
|
if (!cond)
|
2005-04-17 22:31:59 +04:00
|
|
|
break;
|
2005-11-01 04:13:36 +03:00
|
|
|
/* Filter passed *vp, push as result. */
|
2005-04-17 22:31:59 +04:00
|
|
|
ok = IndexToId(cx, newlen++, &id);
|
|
|
|
if (!ok)
|
|
|
|
goto out;
|
2005-11-01 04:13:36 +03:00
|
|
|
ok = OBJ_SET_PROPERTY(cx, newarr, id, vp);
|
2005-04-17 22:31:59 +04:00
|
|
|
if (!ok)
|
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
case SOME:
|
2006-04-27 04:39:43 +04:00
|
|
|
if (cond) {
|
2005-04-17 22:31:59 +04:00
|
|
|
*rval = JSVAL_TRUE;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EVERY:
|
2006-04-27 04:39:43 +04:00
|
|
|
if (!cond) {
|
2005-04-17 22:31:59 +04:00
|
|
|
*rval = JSVAL_FALSE;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
js_FreeStack(cx, mark);
|
|
|
|
if (ok && mode == FILTER)
|
|
|
|
ok = js_SetLengthProperty(cx, newarr, newlen);
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_forEach(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
|
|
jsval *rval)
|
|
|
|
{
|
|
|
|
return array_extra(cx, obj, argc, argv, rval, FOREACH);
|
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_map(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
|
|
jsval *rval)
|
|
|
|
{
|
|
|
|
return array_extra(cx, obj, argc, argv, rval, MAP);
|
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_filter(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
|
|
jsval *rval)
|
|
|
|
{
|
|
|
|
return array_extra(cx, obj, argc, argv, rval, FILTER);
|
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_some(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
|
|
jsval *rval)
|
|
|
|
{
|
|
|
|
return array_extra(cx, obj, argc, argv, rval, SOME);
|
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
array_every(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
|
|
jsval *rval)
|
|
|
|
{
|
|
|
|
return array_extra(cx, obj, argc, argv, rval, EVERY);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
static JSFunctionSpec array_methods[] = {
|
1998-04-24 04:31:11 +04:00
|
|
|
#if JS_HAS_TOSOURCE
|
2000-08-10 01:46:03 +04:00
|
|
|
{js_toSource_str, array_toSource, 0,0,0},
|
1998-04-24 04:31:11 +04:00
|
|
|
#endif
|
2000-08-10 01:46:03 +04:00
|
|
|
{js_toString_str, array_toString, 0,0,0},
|
|
|
|
{js_toLocaleString_str, array_toLocaleString, 0,0,0},
|
1998-03-28 05:44:41 +03:00
|
|
|
|
|
|
|
/* Perl-ish methods. */
|
2005-08-30 08:28:45 +04:00
|
|
|
{"join", array_join, 1,JSFUN_GENERIC_NATIVE,0},
|
2005-10-11 03:33:16 +04:00
|
|
|
{"reverse", array_reverse, 0,JSFUN_GENERIC_NATIVE,2},
|
2005-10-12 11:39:45 +04:00
|
|
|
{"sort", array_sort, 1,JSFUN_GENERIC_NATIVE,2},
|
2005-08-30 08:28:45 +04:00
|
|
|
{"push", array_push, 1,JSFUN_GENERIC_NATIVE,0},
|
|
|
|
{"pop", array_pop, 0,JSFUN_GENERIC_NATIVE,0},
|
2005-11-01 04:13:36 +03:00
|
|
|
{"shift", array_shift, 0,JSFUN_GENERIC_NATIVE,1},
|
|
|
|
{"unshift", array_unshift, 1,JSFUN_GENERIC_NATIVE,1},
|
|
|
|
{"splice", array_splice, 2,JSFUN_GENERIC_NATIVE,1},
|
1998-03-28 05:44:41 +03:00
|
|
|
|
|
|
|
/* Python-esque sequence methods. */
|
2005-11-01 04:13:36 +03:00
|
|
|
{"concat", array_concat, 1,JSFUN_GENERIC_NATIVE,1},
|
|
|
|
{"slice", array_slice, 2,JSFUN_GENERIC_NATIVE,1},
|
1998-03-28 05:44:41 +03:00
|
|
|
|
2005-04-17 22:31:59 +04:00
|
|
|
#if JS_HAS_ARRAY_EXTRAS
|
2005-08-30 08:28:45 +04:00
|
|
|
{"indexOf", array_indexOf, 1,JSFUN_GENERIC_NATIVE,0},
|
|
|
|
{"lastIndexOf", array_lastIndexOf, 1,JSFUN_GENERIC_NATIVE,0},
|
2005-11-01 04:13:36 +03:00
|
|
|
{"forEach", array_forEach, 1,JSFUN_GENERIC_NATIVE,1},
|
|
|
|
{"map", array_map, 1,JSFUN_GENERIC_NATIVE,1},
|
|
|
|
{"filter", array_filter, 1,JSFUN_GENERIC_NATIVE,1},
|
|
|
|
{"some", array_some, 1,JSFUN_GENERIC_NATIVE,1},
|
|
|
|
{"every", array_every, 1,JSFUN_GENERIC_NATIVE,1},
|
2005-04-17 22:31:59 +04:00
|
|
|
#endif
|
|
|
|
|
1999-11-12 00:52:35 +03:00
|
|
|
{0,0,0,0,0}
|
1998-03-28 05:44:41 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
Array(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
jsuint length;
|
1998-03-28 05:44:41 +03:00
|
|
|
jsval *vector;
|
1998-04-24 04:31:11 +04:00
|
|
|
|
|
|
|
/* If called without new, replace obj with a new Array object. */
|
Fix for bug 99663 (for loop resolves properties of the object being enumerated
with JSRESOLVE_ASSIGNING, wrongly), plus a few miscellaneous bugfixes.
- Combine the JSStackFrame members constructing, special, overrides, and
reserved into a uint32 flags member.
- Separate JOF_ASSIGNING from the JOF_SET bytecode format flag, and impute
JSRESOLVE_ASSIGNING from the presence of JOF_ASSIGNING among the current
opcode's format flags. To handle the for-in loop opcodes, which do more
than simply assign -- in particular, they do property lookups whose resolve
hook outcalls should not be flagged with JSRESOLVE_ASSIGNING -- a new frame
flag, JSFRAME_ASSIGNING, has been added.
- Fix interpreter version selection to respect JS_SetVersion, whose effect on
cx->version is "sticky".
- Fix js_DecompileValueGenerator to deal with JSOP_ENUMELEM -- it never had,
as this testcase shows (it crashes without this patch):
version(120);
eval("function fe(s) { for (it[s] in this); }");
try { fe('rdonly'); } catch (e) { print(e); }
2001-10-03 10:39:30 +04:00
|
|
|
if (!(cx->fp->flags & JSFRAME_CONSTRUCTING)) {
|
2003-06-12 04:26:40 +04:00
|
|
|
obj = js_NewObject(cx, &js_ArrayClass, NULL, NULL);
|
|
|
|
if (!obj)
|
|
|
|
return JS_FALSE;
|
|
|
|
*rval = OBJECT_TO_JSVAL(obj);
|
1998-04-24 04:31:11 +04:00
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
|
|
|
|
if (argc == 0) {
|
2003-06-12 04:26:40 +04:00
|
|
|
length = 0;
|
|
|
|
vector = NULL;
|
|
|
|
} else if (argc > 1) {
|
|
|
|
length = (jsuint) argc;
|
|
|
|
vector = argv;
|
|
|
|
} else if (!JSVAL_IS_NUMBER(argv[0])) {
|
|
|
|
length = 1;
|
|
|
|
vector = argv;
|
1998-03-28 05:44:41 +03:00
|
|
|
} else {
|
2003-06-12 04:26:40 +04:00
|
|
|
if (!ValueIsLength(cx, argv[0], &length))
|
|
|
|
return JS_FALSE;
|
|
|
|
vector = NULL;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
1998-04-24 04:31:11 +04:00
|
|
|
return InitArrayObject(cx, obj, length, vector);
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
JSObject *
|
|
|
|
js_InitArrayClass(JSContext *cx, JSObject *obj)
|
|
|
|
{
|
1998-04-24 04:31:11 +04:00
|
|
|
JSObject *proto;
|
|
|
|
|
|
|
|
proto = JS_InitClass(cx, obj, NULL, &js_ArrayClass, Array, 1,
|
2003-06-12 04:26:40 +04:00
|
|
|
NULL, array_methods, NULL, NULL);
|
1998-04-24 04:31:11 +04:00
|
|
|
|
|
|
|
/* Initialize the Array prototype object so it gets a length property. */
|
|
|
|
if (!proto || !InitArrayObject(cx, proto, 0, NULL))
|
2003-06-12 04:26:40 +04:00
|
|
|
return NULL;
|
1998-04-24 04:31:11 +04:00
|
|
|
return proto;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
JSObject *
|
1998-04-24 04:31:11 +04:00
|
|
|
js_NewArrayObject(JSContext *cx, jsuint length, jsval *vector)
|
1998-03-28 05:44:41 +03:00
|
|
|
{
|
|
|
|
JSObject *obj;
|
|
|
|
|
|
|
|
obj = js_NewObject(cx, &js_ArrayClass, NULL, NULL);
|
|
|
|
if (!obj)
|
2003-06-12 04:26:40 +04:00
|
|
|
return NULL;
|
1998-03-28 05:44:41 +03:00
|
|
|
if (!InitArrayObject(cx, obj, length, vector)) {
|
2003-06-12 04:26:40 +04:00
|
|
|
cx->newborn[GCX_OBJECT] = NULL;
|
|
|
|
return NULL;
|
1998-03-28 05:44:41 +03:00
|
|
|
}
|
|
|
|
return obj;
|
|
|
|
}
|