/*
* Perl-inspired push, pop, shift, unshift, and splice methods.
*/
static JSBool
array_push(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
jsuint length;
uintN i;
jsid id;
if (!js_GetLengthProperty(cx, obj, &length))
return JS_FALSE;
for (i = 0; i < argc; i++) {
if (!IndexToId(cx, length + i, &id))
return JS_FALSE;
if (!OBJ_SET_PROPERTY(cx, obj, id, &argv[i]))
return JS_FALSE;
}
/*
* If JS1.2, follow Perl4 by returning the last thing pushed. Otherwise,
* return the new array length.
*/
length += argc;
if (cx->version == JSVERSION_1_2) {
*rval = argc ? argv[argc-1] : JSVAL_VOID;
} else {
if (!IndexToValue(cx, length, rval))
return JS_FALSE;
}
return js_SetLengthProperty(cx, obj, length);
}
static JSBool
array_slice(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
JSObject *nobj;
jsuint length, begin, end, slot;
jsdouble d;
jsid id, id2;
jsval v;
nobj = js_NewArrayObject(cx, 0, NULL);
if (!nobj)
return JS_FALSE;
if (!js_GetLengthProperty(cx, obj, &length))
return JS_FALSE;
begin = 0;
end = length;
if (argc > 0) {
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;
}
}
for (slot = begin; slot < end; slot++) {
if (!IndexToId(cx, slot, &id))
return JS_FALSE;
if (!IndexToId(cx, slot - begin, &id2))
return JS_FALSE;
if (!OBJ_GET_PROPERTY(cx, obj, id, &v))
return JS_FALSE;
if (!OBJ_SET_PROPERTY(cx, nobj, id2, &v))
return JS_FALSE;
}
*rval = OBJECT_TO_JSVAL(nobj);
return JS_TRUE;
}
static JSBool
array_unshift(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
jsval *rval)
{
jsuint length, last;
uintN i;
jsid id, id2;
jsval v;
#if JS_HAS_SPARSE_ARRAYS
JSObject *obj2;
JSProperty *prop;
#endif
if (!js_GetLengthProperty(cx, obj, &length))
return JS_FALSE;
if (argc > 0) {
/* Slide up the array to make room for argc at the bottom. */
if (length > 0) {
last = length;
while (last--) {
if (!IndexToId(cx, last, &id))
return JS_FALSE;
if (!IndexToId(cx, last + argc, &id2))
return JS_FALSE;
#if JS_HAS_SPARSE_ARRAYS
if (!OBJ_LOOKUP_PROPERTY(cx, obj, id, &obj2, &prop))
return JS_FALSE;
if (!prop) {
OBJ_DELETE_PROPERTY(cx, obj, id2, &v); /* v is junk. */
continue;
}
OBJ_DROP_PROPERTY(cx, obj2, prop);
#endif
if (!OBJ_GET_PROPERTY(cx, obj, id, &v))
return JS_FALSE;
if (!OBJ_SET_PROPERTY(cx, obj, id2, &v))
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;
}
return IndexToValue(cx, length, rval);
}
static JSBool
CloseObject(JSContext *cx, JSONParser *jp)
{
jsuint len;
if (!js_GetLengthProperty(cx, jp->objectStack, &len))
return JS_FALSE;
if (!js_SetLengthProperty(cx, jp->objectStack, len - 1))
return JS_FALSE;
return JS_TRUE;
}
static JSObject *
GetTopOfObjectStack(JSContext *cx, JSONParser *jp)
{
jsuint length;
if (!js_GetLengthProperty(cx, jp->objectStack, &length))
return NULL;
jsval o;
if (!OBJ_GET_PROPERTY(cx, jp->objectStack, INT_TO_JSID(length - 1), &o))
return NULL;
JS_ASSERT(!JSVAL_IS_PRIMITIVE(o));
return JSVAL_TO_OBJECT(o);
}
static JSBool
array_addProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
jsuint index, length;
if (!(IdIsIndex(id, &index)))
return JS_TRUE;
if (!js_GetLengthProperty(cx, obj, &length))
return JS_FALSE;
if (index >= length) {
length = index + 1;
return js_SetLengthProperty(cx, obj, length);
}
return JS_TRUE;
}
static JSBool
JA(JSContext *cx, jsval *vp, StringifyContext *scx)
{
JSObject *obj = JSVAL_TO_OBJECT(*vp);
if (!scx->cb.append('['))
return JS_FALSE;
jsuint length;
if (!js_GetLengthProperty(cx, obj, &length))
return JS_FALSE;
jsval outputValue = JSVAL_NULL;
JSAutoTempValueRooter tvr(cx, 1, &outputValue);
jsid id;
jsuint i;
for (i = 0; i < length; i++) {
id = INT_TO_JSID(i);
if (!obj->getProperty(cx, id, &outputValue))
return JS_FALSE;
if (!Str(cx, id, obj, scx, &outputValue))
return JS_FALSE;
if (outputValue == JSVAL_VOID) {
if (!js_AppendLiteral(scx->cb, "null"))
return JS_FALSE;
}
if (i < length - 1) {
if (!scx->cb.append(','))
return JS_FALSE;
if (!WriteIndent(cx, scx, scx->depth))
return JS_FALSE;
}
}
if (length != 0 && !WriteIndent(cx, scx, scx->depth - 1))
return JS_FALSE;
return scx->cb.append(']');
}
static JSBool
array_reverse(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
jsval *rval)
{
jsuint len, half, i;
jsid id, id2;
jsval v, v2;
if (!js_GetLengthProperty(cx, obj, &len))
return JS_FALSE;
half = len / 2;
for (i = 0; i < half; i++) {
if (!IndexToId(cx, i, &id))
return JS_FALSE;
if (!IndexToId(cx, len - i - 1, &id2))
return JS_FALSE;
if (!OBJ_GET_PROPERTY(cx, obj, id, &v))
return JS_FALSE;
if (!OBJ_GET_PROPERTY(cx, obj, id2, &v2))
return JS_FALSE;
#if JS_HAS_SPARSE_ARRAYS
/* This part isn't done yet. */
if (!OBJ_LOOKUP_PROPERTY(cx, obj, id, &obj2, &prop))
return JS_FALSE;
if (!prop) {
OBJ_DELETE_PROPERTY(cx, obj, id2, &v); /* v is junk. */
continue;
}
OBJ_DROP_PROPERTY(cx, obj2, prop);
#endif
if (!OBJ_SET_PROPERTY(cx, obj, id, &v2))
return JS_FALSE;
if (!OBJ_SET_PROPERTY(cx, obj, id2, &v))
return JS_FALSE;
}
*rval = OBJECT_TO_JSVAL(obj);
return JS_TRUE;
}
static JSBool
array_convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
{
jsuint length;
if (cx->version == JSVERSION_1_2) {
if (!js_GetLengthProperty(cx, obj, &length))
return JS_FALSE;
switch (type) {
case JSTYPE_NUMBER:
return IndexToValue(cx, length, vp);
case JSTYPE_BOOLEAN:
*vp = BOOLEAN_TO_JSVAL(length > 0);
return JS_TRUE;
default:
return JS_TRUE;
}
}
return js_TryValueOf(cx, obj, type, vp);
}
static JSBool
array_length_setter(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
jsuint newlen, oldlen, slot;
jsid id2;
jsval junk;
if (!ValueIsLength(cx, *vp, &newlen))
return JS_FALSE;
if (!js_GetLengthProperty(cx, obj, &oldlen))
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;
}
return IndexToValue(cx, newlen, vp);
}
static JSBool
PushObject(JSContext *cx, JSONParser *jp, JSObject *obj)
{
jsuint len;
if (!js_GetLengthProperty(cx, jp->objectStack, &len))
return JS_FALSE;
if (len >= JSON_MAX_DEPTH)
return JS_FALSE; // decoding error
jsval v = OBJECT_TO_JSVAL(obj);
JSAutoTempValueRooter tvr(cx, v);
// Check if this is the root object
if (len == 0) {
*jp->rootVal = v;
// This property must be enumerable to keep the array dense
if (!OBJ_DEFINE_PROPERTY(cx, jp->objectStack, INT_TO_JSID(0), *jp->rootVal,
NULL, NULL, JSPROP_ENUMERATE, NULL)) {
return JS_FALSE;
}
return JS_TRUE;
}
jsval p;
if (!OBJ_GET_PROPERTY(cx, jp->objectStack, INT_TO_JSID(len - 1), &p))
return JS_FALSE;
JS_ASSERT(JSVAL_IS_OBJECT(p));
JSObject *parent = JSVAL_TO_OBJECT(p);
if (!PushValue(cx, jp, parent, OBJECT_TO_JSVAL(obj)))
return JS_FALSE;
// This property must be enumerable to keep the array dense
if (!OBJ_DEFINE_PROPERTY(cx, jp->objectStack, INT_TO_JSID(len), v,
NULL, NULL, JSPROP_ENUMERATE, NULL)) {
return JS_FALSE;
}
return JS_TRUE;
}
static JSBool
array_shift(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
jsuint length, i;
jsid id, id2;
jsval v, junk;
if (!js_GetLengthProperty(cx, obj, &length))
return JS_FALSE;
if (length > 0) {
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;
if (!OBJ_GET_PROPERTY(cx, obj, id, &v))
return JS_FALSE;
if (!OBJ_SET_PROPERTY(cx, obj, id2, &v))
return JS_FALSE;
}
}
/* Delete the only or last element. */
if (!OBJ_DELETE_PROPERTY(cx, obj, id, &junk))
return JS_FALSE;
}
return js_SetLengthProperty(cx, obj, length);
}
static JSBool
array_pop(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
jsuint index;
jsid id;
jsval junk;
if (!js_GetLengthProperty(cx, obj, &index))
return JS_FALSE;
if (index > 0) {
index--;
if (!IndexToId(cx, index, &id))
return JS_FALSE;
/* Get the to-be-deleted property's value into rval. */
if (!OBJ_GET_PROPERTY(cx, obj, id, rval))
return JS_FALSE;
if (!OBJ_DELETE_PROPERTY(cx, obj, id, &junk))
return JS_FALSE;
}
return js_SetLengthProperty(cx, obj, index);
}
static JSBool
PushValue(JSContext *cx, JSONParser *jp, JSObject *parent, jsval value)
{
JSAutoTempValueRooter tvr(cx, 1, &value);
JSBool ok;
if (OBJ_IS_ARRAY(cx, parent)) {
jsuint len;
ok = js_GetLengthProperty(cx, parent, &len);
if (ok) {
ok = OBJ_DEFINE_PROPERTY(cx, parent, INT_TO_JSID(len), value,
NULL, NULL, JSPROP_ENUMERATE, NULL);
}
} else {
ok = JS_DefineUCProperty(cx, parent, jp->objectKey->base,
STRING_BUFFER_OFFSET(jp->objectKey), value,
NULL, NULL, JSPROP_ENUMERATE);
js_FinishStringBuffer(jp->objectKey);
js_InitStringBuffer(jp->objectKey);
}
return ok;
}
JSBool
js_Stringify(JSContext *cx, jsval *vp, JSObject *replacer,
JSONWriteCallback callback, void *data, uint32 depth)
{
if (depth > JSON_MAX_DEPTH)
return JS_FALSE; /* encoding error */
JSBool ok = JS_TRUE;
JSObject *obj = JSVAL_TO_OBJECT(*vp);
JSBool isArray = JS_IsArrayObject(cx, obj);
jschar output = jschar(isArray ? '[' : '{');
if (!callback(&output, 1, data))
return JS_FALSE;
JSObject *iterObj = NULL;
jsint i = 0;
jsuint length = 0;
if (isArray) {
if (!js_GetLengthProperty(cx, obj, &length))
return JS_FALSE;
} else {
if (!js_ValueToIterator(cx, JSITER_ENUMERATE, vp))
return JS_FALSE;
iterObj = JSVAL_TO_OBJECT(*vp);
}
jsval outputValue = JSVAL_VOID;
JSAutoTempValueRooter tvr(cx, 1, &outputValue);
jsval key;
JSBool memberWritten = JS_FALSE;
do {
outputValue = JSVAL_VOID;
if (isArray) {
if ((jsuint)i >= length)
break;
ok = OBJ_GET_PROPERTY(cx, obj, INT_TO_JSID(i), &outputValue);
i++;
} else {
ok = js_CallIteratorNext(cx, iterObj, &key);
if (!ok)
break;
if (key == JSVAL_HOLE)
break;
JSString *ks;
if (JSVAL_IS_STRING(key)) {
ks = JSVAL_TO_STRING(key);
} else {
ks = js_ValueToString(cx, key);
if (!ks) {
ok = JS_FALSE;
break;
}
}
ok = JS_GetUCProperty(cx, obj, JS_GetStringChars(ks),
JS_GetStringLength(ks), &outputValue);
}
if (!ok)
break;
// if this is an array, holes are transmitted as null
if (isArray && outputValue == JSVAL_VOID) {
outputValue = JSVAL_NULL;
} else if (JSVAL_IS_OBJECT(outputValue)) {
ok = js_TryJSON(cx, &outputValue);
if (!ok)
break;
}
// elide undefined values
if (outputValue == JSVAL_VOID)
continue;
// output a comma unless this is the first member to write
if (memberWritten) {
output = jschar(',');
ok = callback(&output, 1, data);
if (!ok)
break;
}
memberWritten = JS_TRUE;
JSType type = JS_TypeOfValue(cx, outputValue);
// Can't encode these types, so drop them
if (type == JSTYPE_FUNCTION || type == JSTYPE_XML)
break;
// Be careful below, this string is weakly rooted.
JSString *s;
// If this isn't an array, we need to output a key
if (!isArray) {
s = js_ValueToString(cx, key);
if (!s) {
ok = JS_FALSE;
break;
}
ok = write_string(cx, callback, data, JS_GetStringChars(s), JS_GetStringLength(s));
if (!ok)
break;
output = jschar(':');
ok = callback(&output, 1, data);
if (!ok)
break;
}
if (!JSVAL_IS_PRIMITIVE(outputValue)) {
// recurse
ok = js_Stringify(cx, &outputValue, replacer, callback, data, depth + 1);
} else {
JSString *outputString;
s = js_ValueToString(cx, outputValue);
if (!s) {
ok = JS_FALSE;
break;
}
if (type == JSTYPE_STRING) {
ok = write_string(cx, callback, data, JS_GetStringChars(s), JS_GetStringLength(s));
if (!ok)
break;
continue;
}
if (type == JSTYPE_NUMBER) {
if (JSVAL_IS_DOUBLE(outputValue)) {
jsdouble d = *JSVAL_TO_DOUBLE(outputValue);
if (!JSDOUBLE_IS_FINITE(d))
outputString = JS_NewStringCopyN(cx, "null", 4);
else
outputString = s;
} else {
outputString = s;
}
} else if (type == JSTYPE_BOOLEAN) {
outputString = s;
} else if (JSVAL_IS_NULL(outputValue)) {
outputString = JS_NewStringCopyN(cx, "null", 4);
} else {
ok = JS_FALSE; // encoding error
break;
}
if (!outputString) {
ok = JS_FALSE;
break;
}
ok = callback(JS_GetStringChars(outputString), JS_GetStringLength(outputString), data);
}
} while (ok);
if (iterObj) {
// Always close the iterator, but make sure not to stomp on OK
ok &= js_CloseIterator(cx, *vp);
// encoding error or propagate? FIXME: Bug 408838.
}
if (!ok) {
JS_ReportError(cx, "Error during JSON encoding");
return JS_FALSE;
}
output = jschar(isArray ? ']' : '}');
ok = callback(&output, 1, data);
return ok;
}
static JSBool
array_splice(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
jsuint length, begin, end, count, delta, last;
uintN i;
jsdouble d;
jsid id, id2;
jsval v;
JSObject *obj2;
/* Nothing to do if no args. Otherwise lock and load length. */
if (argc == 0)
return JS_TRUE;
if (!js_GetLengthProperty(cx, obj, &length))
return JS_FALSE;
/* Convert the first argument into a starting index. */
if (!js_ValueToNumber(cx, *argv, &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; /* d has been clamped to uint32 */
argc--;
argv++;
/* Convert the second argument from a count into a fencepost index. */
delta = length - begin;
if (argc == 0) {
count = delta;
end = length;
} else {
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++;
}
if (count == 1 && cx->version == JSVERSION_1_2) {
/*
* JS lacks "list context", whereby in Perl one turns the single
* scalar that's spliced out into an array just by assigning it to
* @single instead of $single, or by using it as Perl push's first
* argument, for instance.
*
* JS1.2 emulated Perl too closely and returned a non-Array for
* the single-splice-out case, requiring callers to test and wrap
* in [] if necessary. So JS1.3, default, and other versions all
* return an array of length 1 for uniformity.
*/
if (!IndexToId(cx, begin, &id))
return JS_FALSE;
if (!OBJ_GET_PROPERTY(cx, obj, id, rval))
return JS_FALSE;
} else {
if (cx->version != JSVERSION_1_2 || count > 0) {
/*
* 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);
/* If there are elements to remove, put them into the return value. */
if (count > 0) {
for (last = begin; last < end; last++) {
if (!IndexToId(cx, last, &id))
return JS_FALSE;
if (!IndexToId(cx, last - begin, &id2))
return JS_FALSE;
if (!OBJ_GET_PROPERTY(cx, obj, id, &v))
return JS_FALSE;
if (!OBJ_SET_PROPERTY(cx, obj2, id2, &v))
return JS_FALSE;
}
}
}
}
/* Find the direction (up or down) to copy and make way for argv. */
if (argc > count) {
delta = (jsuint)argc - count;
last = length;
/* (uint) end could be 0, so can't use vanilla >= test */
while (last-- > end) {
if (!IndexToId(cx, last, &id))
return JS_FALSE;
if (!IndexToId(cx, last + delta, &id2))
return JS_FALSE;
if (!OBJ_GET_PROPERTY(cx, obj, id, &v))
return JS_FALSE;
if (!OBJ_SET_PROPERTY(cx, obj, id2, &v))
return JS_FALSE;
}
length += delta;
} else if (argc < count) {
delta = count - (jsuint)argc;
for (last = end; last < length; last++) {
if (!IndexToId(cx, last, &id))
return JS_FALSE;
if (!IndexToId(cx, last - delta, &id2))
return JS_FALSE;
if (!OBJ_GET_PROPERTY(cx, obj, id, &v))
return JS_FALSE;
if (!OBJ_SET_PROPERTY(cx, obj, id2, &v))
return JS_FALSE;
}
length -= delta;
}
/* Copy from argv into the hole to complete the splice. */
for (i = 0; i < argc; i++) {
if (!IndexToId(cx, begin + i, &id))
return JS_FALSE;
if (!OBJ_SET_PROPERTY(cx, obj, id, &argv[i]))
return JS_FALSE;
}
/* Update length in case we deleted elements from the end. */
return js_SetLengthProperty(cx, obj, length);
}
/* XXXmccabe do the sort helper functions need to take int? (Or can we claim
* that 2^32 * 32 is too large to worry about?) Something dumps when I change
* to unsigned int; is qsort using -1 as a fencepost?
*/
static JSBool
array_sort(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
jsval fval;
CompareArgs ca;
jsuint len, newlen, i;
jsval *vec;
jsid id;
size_t nbytes;
/*
* Optimize the default compare function case if all of obj's elements
* have values of type string.
*/
JSBool all_strings;
if (argc > 0) {
if (JSVAL_IS_PRIMITIVE(argv[0])) {
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
JSMSG_BAD_SORT_ARG);
return JS_FALSE;
}
fval = argv[0];
all_strings = JS_FALSE; /* non-default compare function */
} else {
fval = JSVAL_NULL;
all_strings = JS_TRUE; /* check for all string values */
}
if (!js_GetLengthProperty(cx, obj, &len))
return JS_FALSE;
if (len == 0) {
*rval = OBJECT_TO_JSVAL(obj);
return JS_TRUE;
}
/*
* Test for size_t overflow, which could lead to indexing beyond the end
* of the malloc'd vector.
*/
nbytes = len * sizeof(jsval);
if (nbytes != (double) len * sizeof(jsval)) {
JS_ReportOutOfMemory(cx);
return JS_FALSE;
}
vec = (jsval *) JS_malloc(cx, nbytes);
if (!vec)
return JS_FALSE;
#if JS_HAS_SPARSE_ARRAYS
newlen = 0;
#else
newlen = len;
#endif
for (i = 0; i < len; i++) {
ca.status = IndexToId(cx, i, &id);
if (!ca.status)
goto out;
#if JS_HAS_SPARSE_ARRAYS
{
JSObject *obj2;
JSProperty *prop;
ca.status = OBJ_LOOKUP_PROPERTY(cx, obj, id, &obj2, &prop);
if (!ca.status)
goto out;
if (!prop) {
vec[i] = JSVAL_VOID;
continue;
}
OBJ_DROP_PROPERTY(cx, obj2, prop);
newlen++;
}
#endif
ca.status = OBJ_GET_PROPERTY(cx, obj, id, &vec[i]);
if (!ca.status)
goto out;
/* We know JSVAL_IS_STRING yields 0 or 1, so avoid a branch via &=. */
all_strings &= JSVAL_IS_STRING(vec[i]);
}
ca.context = cx;
ca.fval = fval;
ca.status = JS_TRUE;
if (!js_HeapSort(vec, (size_t) len, sizeof(jsval),
all_strings ? sort_compare_strings : sort_compare,
&ca)) {
JS_ReportOutOfMemory(cx);
ca.status = JS_FALSE;
}
if (ca.status) {
ca.status = InitArrayElements(cx, obj, newlen, vec);
if (ca.status)
*rval = OBJECT_TO_JSVAL(obj);
#if JS_HAS_SPARSE_ARRAYS
/* set length of newly-created array object to old length. */
if (ca.status && newlen < len) {
ca.status = js_SetLengthProperty(cx, obj, len);
/* Delete any leftover properties greater than newlen. */
while (ca.status && newlen < len) {
jsval junk;
ca.status = !IndexToId(cx, newlen, &id) ||
!OBJ_DELETE_PROPERTY(cx, obj, id, &junk);
newlen++;
}
}
#endif
}
out:
if (vec)
JS_free(cx, vec);
return ca.status;
}
static JSBool
array_join_sub(JSContext *cx, JSObject *obj, JSString *sep, JSBool literalize,
jsval *rval, JSBool localeString)
{
JSBool ok;
jsval v;
jsuint length, index;
jschar *chars, *ochars;
size_t nchars, growth, seplen, tmplen;
const jschar *sepstr;
JSString *str;
JSHashEntry *he;
JSObject *obj2;
ok = js_GetLengthProperty(cx, obj, &length);
if (!ok)
return JS_FALSE;
he = js_EnterSharpObject(cx, obj, NULL, &chars);
if (!he)
return JS_FALSE;
if (literalize) {
if (IS_SHARP(he)) {
#if JS_HAS_SHARP_VARS
nchars = js_strlen(chars);
#else
chars[0] = '[';
chars[1] = ']';
chars[2] = 0;
nchars = 2;
#endif
goto make_string;
}
/*
* Allocate 1 + 3 + 1 for "[", the worst-case closing ", ]", and the
* terminating 0.
*/
growth = (1 + 3 + 1) * sizeof(jschar);
if (!chars) {
nchars = 0;
chars = (jschar *) malloc(growth);
if (!chars)
goto done;
} else {
MAKE_SHARP(he);
nchars = js_strlen(chars);
chars = (jschar *)
realloc((ochars = chars), nchars * sizeof(jschar) + growth);
if (!chars) {
free(ochars);
goto done;
}
}
chars[nchars++] = '[';
} else {
/*
* 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
* case of (!literalize), we don't need chars at all.
*/
if (chars)
JS_free(cx, chars);
chars = NULL;
nchars = 0;
/* Return the empty string on a cycle as well as on empty join. */
if (IS_BUSY(he) || length == 0) {
js_LeaveSharpObject(cx, NULL);
*rval = JS_GetEmptyStringValue(cx);
return ok;
}
/* Flag he as BUSY so we can distinguish a cycle from a join-point. */
MAKE_BUSY(he);
}
sepstr = NULL;
seplen = JSSTRING_LENGTH(sep);
v = JSVAL_NULL;
for (index = 0; index < length; index++) {
ok = JS_GetElement(cx, obj, index, &v);
if (!ok)
goto done;
if (!literalize && (JSVAL_IS_VOID(v) || JSVAL_IS_NULL(v))) {
str = cx->runtime->emptyString;
} else {
if (localeString) {
if (!js_ValueToObject(cx, v, &obj2) ||
!js_TryMethod(cx, obj2,
cx->runtime->atomState.toLocaleStringAtom,
0, NULL, &v)) {
str = NULL;
} else {
str = js_ValueToString(cx, v);
}
} else {
str = (literalize ? js_ValueToSource : js_ValueToString)(cx, v);
}
if (!str) {
ok = JS_FALSE;
goto done;
}
}
/* Allocate 3 + 1 at end for ", ", closing bracket, and zero. */
growth = (nchars + (sepstr ? seplen : 0) +
JSSTRING_LENGTH(str) +
3 + 1) * sizeof(jschar);
if (!chars) {
chars = (jschar *) malloc(growth);
if (!chars)
goto done;
} else {
chars = (jschar *) realloc((ochars = chars), growth);
if (!chars) {
free(ochars);
goto done;
}
}
if (sepstr) {
js_strncpy(&chars[nchars], sepstr, seplen);
nchars += seplen;
}
sepstr = JSSTRING_CHARS(sep);
tmplen = JSSTRING_LENGTH(str);
js_strncpy(&chars[nchars], JSSTRING_CHARS(str), tmplen);
nchars += tmplen;
}
done:
if (literalize) {
if (chars) {
if (JSVAL_IS_VOID(v)) {
chars[nchars++] = ',';
chars[nchars++] = ' ';
}
chars[nchars++] = ']';
}
} else {
CLEAR_BUSY(he);
}
js_LeaveSharpObject(cx, NULL);
if (!ok) {
if (chars)
free(chars);
return ok;
}
make_string:
if (!chars) {
JS_ReportOutOfMemory(cx);
return JS_FALSE;
}
chars[nchars] = 0;
str = js_NewString(cx, chars, nchars, 0);
if (!str) {
free(chars);
return JS_FALSE;
}
*rval = STRING_TO_JSVAL(str);
return JS_TRUE;
}