mirror of
https://github.com/ccxvii/mujs.git
synced 2026-02-06 09:51:41 +08:00
a2b628c9cb
Previously, each iteration (except the 1st) did this amount of calls: 2x strlen(result-so-far) + 2x strlen(element) + strlen(sep) Where except one strlen(element) they're implicit inside strcat, and of sizes which we already know. Now each iteration does one strlen(element), and no strcat. The big speedup is avoiding strlen of the result so far (twice) on each iteration - O(N^2), but the other extra 2x strlen can add up too. Join of an array of 2000 strings of 80 chars each: Windows: before: 80ms, after: 2ms Linux: before: 20ms, after: 2ms Measured using Date.now()
766 lines
14 KiB
C
766 lines
14 KiB
C
#include "jsi.h"
|
|
#include "jsvalue.h"
|
|
#include "jsbuiltin.h"
|
|
|
|
int js_getlength(js_State *J, int idx)
|
|
{
|
|
int len;
|
|
js_getproperty(J, idx, "length");
|
|
len = js_tointeger(J, -1);
|
|
js_pop(J, 1);
|
|
return len;
|
|
}
|
|
|
|
void js_setlength(js_State *J, int idx, int len)
|
|
{
|
|
js_pushnumber(J, len);
|
|
js_setproperty(J, idx < 0 ? idx - 1 : idx, "length");
|
|
}
|
|
|
|
int js_hasindex(js_State *J, int idx, int i)
|
|
{
|
|
char buf[32];
|
|
return js_hasproperty(J, idx, js_itoa(buf, i));
|
|
}
|
|
|
|
void js_getindex(js_State *J, int idx, int i)
|
|
{
|
|
char buf[32];
|
|
js_getproperty(J, idx, js_itoa(buf, i));
|
|
}
|
|
|
|
void js_setindex(js_State *J, int idx, int i)
|
|
{
|
|
char buf[32];
|
|
js_setproperty(J, idx, js_itoa(buf, i));
|
|
}
|
|
|
|
void js_delindex(js_State *J, int idx, int i)
|
|
{
|
|
char buf[32];
|
|
js_delproperty(J, idx, js_itoa(buf, i));
|
|
}
|
|
|
|
static void jsB_new_Array(js_State *J)
|
|
{
|
|
int i, top = js_gettop(J);
|
|
|
|
js_newarray(J);
|
|
|
|
if (top == 2) {
|
|
if (js_isnumber(J, 1)) {
|
|
js_copy(J, 1);
|
|
js_setproperty(J, -2, "length");
|
|
} else {
|
|
js_copy(J, 1);
|
|
js_setindex(J, -2, 0);
|
|
}
|
|
} else {
|
|
for (i = 1; i < top; ++i) {
|
|
js_copy(J, i);
|
|
js_setindex(J, -2, i - 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void Ap_concat(js_State *J)
|
|
{
|
|
int i, top = js_gettop(J);
|
|
int n, k, len;
|
|
|
|
js_newarray(J);
|
|
n = 0;
|
|
|
|
for (i = 0; i < top; ++i) {
|
|
js_copy(J, i);
|
|
if (js_isarray(J, -1)) {
|
|
len = js_getlength(J, -1);
|
|
for (k = 0; k < len; ++k)
|
|
if (js_hasindex(J, -1, k))
|
|
js_setindex(J, -3, n++);
|
|
js_pop(J, 1);
|
|
} else {
|
|
js_setindex(J, -2, n++);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void Ap_join(js_State *J)
|
|
{
|
|
char * volatile out = NULL;
|
|
const char *sep;
|
|
const char *r;
|
|
int seplen;
|
|
int k, n, len, outlen, rlen;
|
|
|
|
len = js_getlength(J, 0);
|
|
|
|
if (js_isdefined(J, 1)) {
|
|
sep = js_tostring(J, 1);
|
|
seplen = strlen(sep);
|
|
} else {
|
|
sep = ",";
|
|
seplen = 1;
|
|
}
|
|
|
|
if (len <= 0) {
|
|
js_pushliteral(J, "");
|
|
return;
|
|
}
|
|
|
|
if (js_try(J)) {
|
|
js_free(J, out);
|
|
js_throw(J);
|
|
}
|
|
|
|
n = 1;
|
|
for (k = 0; k < len; ++k) {
|
|
js_getindex(J, 0, k);
|
|
if (js_isundefined(J, -1) || js_isnull(J, -1))
|
|
r = "";
|
|
else
|
|
r = js_tostring(J, -1);
|
|
outlen = n - 1;
|
|
rlen = strlen(r);
|
|
n += rlen;
|
|
|
|
if (k == 0) {
|
|
if (n > JS_STRLIMIT)
|
|
js_rangeerror(J, "invalid string length");
|
|
out = js_malloc(J, (int)n);
|
|
memcpy(out, r, rlen + 1);
|
|
} else {
|
|
n += seplen;
|
|
if (n > JS_STRLIMIT)
|
|
js_rangeerror(J, "invalid string length");
|
|
out = js_realloc(J, out, (int)n);
|
|
memcpy(out + outlen, sep, seplen);
|
|
memcpy(out + outlen + seplen, r, rlen + 1);
|
|
}
|
|
|
|
js_pop(J, 1);
|
|
}
|
|
|
|
js_pushstring(J, out);
|
|
js_endtry(J);
|
|
js_free(J, out);
|
|
}
|
|
|
|
static void Ap_pop(js_State *J)
|
|
{
|
|
int n;
|
|
|
|
n = js_getlength(J, 0);
|
|
|
|
if (n > 0) {
|
|
js_getindex(J, 0, n - 1);
|
|
js_delindex(J, 0, n - 1);
|
|
js_setlength(J, 0, n - 1);
|
|
} else {
|
|
js_setlength(J, 0, 0);
|
|
js_pushundefined(J);
|
|
}
|
|
}
|
|
|
|
static void Ap_push(js_State *J)
|
|
{
|
|
int i, top = js_gettop(J);
|
|
int n;
|
|
|
|
n = js_getlength(J, 0);
|
|
|
|
for (i = 1; i < top; ++i, ++n) {
|
|
js_copy(J, i);
|
|
js_setindex(J, 0, n);
|
|
}
|
|
|
|
js_setlength(J, 0, n);
|
|
|
|
js_pushnumber(J, n);
|
|
}
|
|
|
|
static void Ap_reverse(js_State *J)
|
|
{
|
|
int len, middle, lower;
|
|
|
|
len = js_getlength(J, 0);
|
|
middle = len / 2;
|
|
lower = 0;
|
|
|
|
while (lower != middle) {
|
|
int upper = len - lower - 1;
|
|
int haslower = js_hasindex(J, 0, lower);
|
|
int hasupper = js_hasindex(J, 0, upper);
|
|
if (haslower && hasupper) {
|
|
js_setindex(J, 0, lower);
|
|
js_setindex(J, 0, upper);
|
|
} else if (hasupper) {
|
|
js_setindex(J, 0, lower);
|
|
js_delindex(J, 0, upper);
|
|
} else if (haslower) {
|
|
js_setindex(J, 0, upper);
|
|
js_delindex(J, 0, lower);
|
|
}
|
|
++lower;
|
|
}
|
|
|
|
js_copy(J, 0);
|
|
}
|
|
|
|
static void Ap_shift(js_State *J)
|
|
{
|
|
int k, len;
|
|
|
|
len = js_getlength(J, 0);
|
|
|
|
if (len == 0) {
|
|
js_setlength(J, 0, 0);
|
|
js_pushundefined(J);
|
|
return;
|
|
}
|
|
|
|
js_getindex(J, 0, 0);
|
|
|
|
for (k = 1; k < len; ++k) {
|
|
if (js_hasindex(J, 0, k))
|
|
js_setindex(J, 0, k - 1);
|
|
else
|
|
js_delindex(J, 0, k - 1);
|
|
}
|
|
|
|
js_delindex(J, 0, len - 1);
|
|
js_setlength(J, 0, len - 1);
|
|
}
|
|
|
|
static void Ap_slice(js_State *J)
|
|
{
|
|
int len, s, e, n;
|
|
double sv, ev;
|
|
|
|
js_newarray(J);
|
|
|
|
len = js_getlength(J, 0);
|
|
sv = js_tointeger(J, 1);
|
|
ev = js_isdefined(J, 2) ? js_tointeger(J, 2) : len;
|
|
|
|
if (sv < 0) sv = sv + len;
|
|
if (ev < 0) ev = ev + len;
|
|
|
|
s = sv < 0 ? 0 : sv > len ? len : sv;
|
|
e = ev < 0 ? 0 : ev > len ? len : ev;
|
|
|
|
for (n = 0; s < e; ++s, ++n)
|
|
if (js_hasindex(J, 0, s))
|
|
js_setindex(J, -2, n);
|
|
}
|
|
|
|
struct sortslot {
|
|
js_Value v;
|
|
js_State *J;
|
|
};
|
|
|
|
static int sortcmp(const void *avoid, const void *bvoid)
|
|
{
|
|
const struct sortslot *aslot = avoid, *bslot = bvoid;
|
|
const js_Value *a = &aslot->v, *b = &bslot->v;
|
|
js_State *J = aslot->J;
|
|
const char *sx, *sy;
|
|
double v;
|
|
int c;
|
|
|
|
int unx = (a->type == JS_TUNDEFINED);
|
|
int uny = (b->type == JS_TUNDEFINED);
|
|
if (unx) return !uny;
|
|
if (uny) return -1;
|
|
|
|
if (js_iscallable(J, 1)) {
|
|
js_copy(J, 1); /* copy function */
|
|
js_pushundefined(J);
|
|
js_pushvalue(J, *a);
|
|
js_pushvalue(J, *b);
|
|
js_call(J, 2);
|
|
v = js_tonumber(J, -1);
|
|
c = (v == 0) ? 0 : (v < 0) ? -1 : 1;
|
|
js_pop(J, 1);
|
|
} else {
|
|
js_pushvalue(J, *a);
|
|
js_pushvalue(J, *b);
|
|
sx = js_tostring(J, -2);
|
|
sy = js_tostring(J, -1);
|
|
c = strcmp(sx, sy);
|
|
js_pop(J, 2);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
static void Ap_sort(js_State *J)
|
|
{
|
|
struct sortslot * volatile array = NULL;
|
|
int i, n, len;
|
|
|
|
len = js_getlength(J, 0);
|
|
if (len <= 0) {
|
|
js_copy(J, 0);
|
|
return;
|
|
}
|
|
|
|
if (len >= INT_MAX / (int)sizeof(*array))
|
|
js_rangeerror(J, "array is too large to sort");
|
|
|
|
/* Holding objects where the GC cannot see them is illegal, but if we
|
|
* don't allow the GC to run we can use qsort() on a temporary array of
|
|
* js_Values for fast sorting.
|
|
*/
|
|
++J->gcpause;
|
|
|
|
if (js_try(J)) {
|
|
--J->gcpause;
|
|
js_free(J, array);
|
|
js_throw(J);
|
|
}
|
|
|
|
array = js_malloc(J, len * sizeof *array);
|
|
|
|
n = 0;
|
|
for (i = 0; i < len; ++i) {
|
|
if (js_hasindex(J, 0, i)) {
|
|
array[n].v = *js_tovalue(J, -1);
|
|
array[n].J = J;
|
|
js_pop(J, 1);
|
|
++n;
|
|
}
|
|
}
|
|
|
|
qsort(array, n, sizeof *array, sortcmp);
|
|
|
|
for (i = 0; i < n; ++i) {
|
|
js_pushvalue(J, array[i].v);
|
|
js_setindex(J, 0, i);
|
|
}
|
|
for (i = n; i < len; ++i) {
|
|
js_delindex(J, 0, i);
|
|
}
|
|
|
|
--J->gcpause;
|
|
|
|
js_endtry(J);
|
|
js_free(J, array);
|
|
|
|
js_copy(J, 0);
|
|
}
|
|
|
|
static void Ap_splice(js_State *J)
|
|
{
|
|
int top = js_gettop(J);
|
|
int len, start, del, add, k;
|
|
double f;
|
|
|
|
js_newarray(J);
|
|
|
|
len = js_getlength(J, 0);
|
|
|
|
f = js_tointeger(J, 1);
|
|
if (f < 0) f = f + len;
|
|
start = f < 0 ? 0 : f > len ? len : f;
|
|
|
|
f = js_tointeger(J, 2);
|
|
del = f < 0 ? 0 : f > len - start ? len - start : f;
|
|
|
|
/* copy deleted items to return array */
|
|
for (k = 0; k < del; ++k)
|
|
if (js_hasindex(J, 0, start + k))
|
|
js_setindex(J, -2, k);
|
|
js_setlength(J, -1, del);
|
|
|
|
/* shift the tail to resize the hole left by deleted items */
|
|
add = top - 3;
|
|
if (add < del) {
|
|
for (k = start; k < len - del; ++k) {
|
|
if (js_hasindex(J, 0, k + del))
|
|
js_setindex(J, 0, k + add);
|
|
else
|
|
js_delindex(J, 0, k + add);
|
|
}
|
|
for (k = len; k > len - del + add; --k)
|
|
js_delindex(J, 0, k - 1);
|
|
} else if (add > del) {
|
|
for (k = len - del; k > start; --k) {
|
|
if (js_hasindex(J, 0, k + del - 1))
|
|
js_setindex(J, 0, k + add - 1);
|
|
else
|
|
js_delindex(J, 0, k + add - 1);
|
|
}
|
|
}
|
|
|
|
/* copy new items into the hole */
|
|
for (k = 0; k < add; ++k) {
|
|
js_copy(J, 3 + k);
|
|
js_setindex(J, 0, start + k);
|
|
}
|
|
|
|
js_setlength(J, 0, len - del + add);
|
|
}
|
|
|
|
static void Ap_unshift(js_State *J)
|
|
{
|
|
int i, top = js_gettop(J);
|
|
int k, len;
|
|
|
|
len = js_getlength(J, 0);
|
|
|
|
for (k = len; k > 0; --k) {
|
|
int from = k - 1;
|
|
int to = k + top - 2;
|
|
if (js_hasindex(J, 0, from))
|
|
js_setindex(J, 0, to);
|
|
else
|
|
js_delindex(J, 0, to);
|
|
}
|
|
|
|
for (i = 1; i < top; ++i) {
|
|
js_copy(J, i);
|
|
js_setindex(J, 0, i - 1);
|
|
}
|
|
|
|
js_setlength(J, 0, len + top - 1);
|
|
|
|
js_pushnumber(J, len + top - 1);
|
|
}
|
|
|
|
static void Ap_toString(js_State *J)
|
|
{
|
|
if (!js_iscoercible(J, 0))
|
|
js_typeerror(J, "'this' is not an object");
|
|
js_getproperty(J, 0, "join");
|
|
if (!js_iscallable(J, -1)) {
|
|
js_pop(J, 1);
|
|
// TODO: call Object.prototype.toString implementation directly
|
|
js_getglobal(J, "Object");
|
|
js_getproperty(J, -1, "prototype");
|
|
js_rot2pop1(J);
|
|
js_getproperty(J, -1, "toString");
|
|
js_rot2pop1(J);
|
|
}
|
|
js_copy(J, 0);
|
|
js_call(J, 0);
|
|
}
|
|
|
|
static void Ap_indexOf(js_State *J)
|
|
{
|
|
int k, len, from;
|
|
|
|
len = js_getlength(J, 0);
|
|
from = js_isdefined(J, 2) ? js_tointeger(J, 2) : 0;
|
|
if (from < 0) from = len + from;
|
|
if (from < 0) from = 0;
|
|
|
|
js_copy(J, 1);
|
|
for (k = from; k < len; ++k) {
|
|
if (js_hasindex(J, 0, k)) {
|
|
if (js_strictequal(J)) {
|
|
js_pushnumber(J, k);
|
|
return;
|
|
}
|
|
js_pop(J, 1);
|
|
}
|
|
}
|
|
|
|
js_pushnumber(J, -1);
|
|
}
|
|
|
|
static void Ap_lastIndexOf(js_State *J)
|
|
{
|
|
int k, len, from;
|
|
|
|
len = js_getlength(J, 0);
|
|
from = js_isdefined(J, 2) ? js_tointeger(J, 2) : len - 1;
|
|
if (from > len - 1) from = len - 1;
|
|
if (from < 0) from = len + from;
|
|
|
|
js_copy(J, 1);
|
|
for (k = from; k >= 0; --k) {
|
|
if (js_hasindex(J, 0, k)) {
|
|
if (js_strictequal(J)) {
|
|
js_pushnumber(J, k);
|
|
return;
|
|
}
|
|
js_pop(J, 1);
|
|
}
|
|
}
|
|
|
|
js_pushnumber(J, -1);
|
|
}
|
|
|
|
static void Ap_every(js_State *J)
|
|
{
|
|
int hasthis = js_gettop(J) >= 3;
|
|
int k, len;
|
|
|
|
if (!js_iscallable(J, 1))
|
|
js_typeerror(J, "callback is not a function");
|
|
|
|
len = js_getlength(J, 0);
|
|
for (k = 0; k < len; ++k) {
|
|
if (js_hasindex(J, 0, k)) {
|
|
js_copy(J, 1);
|
|
if (hasthis)
|
|
js_copy(J, 2);
|
|
else
|
|
js_pushundefined(J);
|
|
js_copy(J, -3);
|
|
js_pushnumber(J, k);
|
|
js_copy(J, 0);
|
|
js_call(J, 3);
|
|
if (!js_toboolean(J, -1))
|
|
return;
|
|
js_pop(J, 2);
|
|
}
|
|
}
|
|
|
|
js_pushboolean(J, 1);
|
|
}
|
|
|
|
static void Ap_some(js_State *J)
|
|
{
|
|
int hasthis = js_gettop(J) >= 3;
|
|
int k, len;
|
|
|
|
if (!js_iscallable(J, 1))
|
|
js_typeerror(J, "callback is not a function");
|
|
|
|
len = js_getlength(J, 0);
|
|
for (k = 0; k < len; ++k) {
|
|
if (js_hasindex(J, 0, k)) {
|
|
js_copy(J, 1);
|
|
if (hasthis)
|
|
js_copy(J, 2);
|
|
else
|
|
js_pushundefined(J);
|
|
js_copy(J, -3);
|
|
js_pushnumber(J, k);
|
|
js_copy(J, 0);
|
|
js_call(J, 3);
|
|
if (js_toboolean(J, -1))
|
|
return;
|
|
js_pop(J, 2);
|
|
}
|
|
}
|
|
|
|
js_pushboolean(J, 0);
|
|
}
|
|
|
|
static void Ap_forEach(js_State *J)
|
|
{
|
|
int hasthis = js_gettop(J) >= 3;
|
|
int k, len;
|
|
|
|
if (!js_iscallable(J, 1))
|
|
js_typeerror(J, "callback is not a function");
|
|
|
|
len = js_getlength(J, 0);
|
|
for (k = 0; k < len; ++k) {
|
|
if (js_hasindex(J, 0, k)) {
|
|
js_copy(J, 1);
|
|
if (hasthis)
|
|
js_copy(J, 2);
|
|
else
|
|
js_pushundefined(J);
|
|
js_copy(J, -3);
|
|
js_pushnumber(J, k);
|
|
js_copy(J, 0);
|
|
js_call(J, 3);
|
|
js_pop(J, 2);
|
|
}
|
|
}
|
|
|
|
js_pushundefined(J);
|
|
}
|
|
|
|
static void Ap_map(js_State *J)
|
|
{
|
|
int hasthis = js_gettop(J) >= 3;
|
|
int k, len;
|
|
|
|
if (!js_iscallable(J, 1))
|
|
js_typeerror(J, "callback is not a function");
|
|
|
|
js_newarray(J);
|
|
|
|
len = js_getlength(J, 0);
|
|
for (k = 0; k < len; ++k) {
|
|
if (js_hasindex(J, 0, k)) {
|
|
js_copy(J, 1);
|
|
if (hasthis)
|
|
js_copy(J, 2);
|
|
else
|
|
js_pushundefined(J);
|
|
js_copy(J, -3);
|
|
js_pushnumber(J, k);
|
|
js_copy(J, 0);
|
|
js_call(J, 3);
|
|
js_setindex(J, -3, k);
|
|
js_pop(J, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void Ap_filter(js_State *J)
|
|
{
|
|
int hasthis = js_gettop(J) >= 3;
|
|
int k, to, len;
|
|
|
|
if (!js_iscallable(J, 1))
|
|
js_typeerror(J, "callback is not a function");
|
|
|
|
js_newarray(J);
|
|
to = 0;
|
|
|
|
len = js_getlength(J, 0);
|
|
for (k = 0; k < len; ++k) {
|
|
if (js_hasindex(J, 0, k)) {
|
|
js_copy(J, 1);
|
|
if (hasthis)
|
|
js_copy(J, 2);
|
|
else
|
|
js_pushundefined(J);
|
|
js_copy(J, -3);
|
|
js_pushnumber(J, k);
|
|
js_copy(J, 0);
|
|
js_call(J, 3);
|
|
if (js_toboolean(J, -1)) {
|
|
js_pop(J, 1);
|
|
js_setindex(J, -2, to++);
|
|
} else {
|
|
js_pop(J, 2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void Ap_reduce(js_State *J)
|
|
{
|
|
int hasinitial = js_gettop(J) >= 3;
|
|
int k, len;
|
|
|
|
if (!js_iscallable(J, 1))
|
|
js_typeerror(J, "callback is not a function");
|
|
|
|
len = js_getlength(J, 0);
|
|
k = 0;
|
|
|
|
if (len == 0 && !hasinitial)
|
|
js_typeerror(J, "no initial value");
|
|
|
|
/* initial value of accumulator */
|
|
if (hasinitial)
|
|
js_copy(J, 2);
|
|
else {
|
|
while (k < len)
|
|
if (js_hasindex(J, 0, k++))
|
|
break;
|
|
if (k == len)
|
|
js_typeerror(J, "no initial value");
|
|
}
|
|
|
|
while (k < len) {
|
|
if (js_hasindex(J, 0, k)) {
|
|
js_copy(J, 1);
|
|
js_pushundefined(J);
|
|
js_rot(J, 4); /* accumulator on top */
|
|
js_rot(J, 4); /* property on top */
|
|
js_pushnumber(J, k);
|
|
js_copy(J, 0);
|
|
js_call(J, 4); /* calculate new accumulator */
|
|
}
|
|
++k;
|
|
}
|
|
|
|
/* return accumulator */
|
|
}
|
|
|
|
static void Ap_reduceRight(js_State *J)
|
|
{
|
|
int hasinitial = js_gettop(J) >= 3;
|
|
int k, len;
|
|
|
|
if (!js_iscallable(J, 1))
|
|
js_typeerror(J, "callback is not a function");
|
|
|
|
len = js_getlength(J, 0);
|
|
k = len - 1;
|
|
|
|
if (len == 0 && !hasinitial)
|
|
js_typeerror(J, "no initial value");
|
|
|
|
/* initial value of accumulator */
|
|
if (hasinitial)
|
|
js_copy(J, 2);
|
|
else {
|
|
while (k >= 0)
|
|
if (js_hasindex(J, 0, k--))
|
|
break;
|
|
if (k < 0)
|
|
js_typeerror(J, "no initial value");
|
|
}
|
|
|
|
while (k >= 0) {
|
|
if (js_hasindex(J, 0, k)) {
|
|
js_copy(J, 1);
|
|
js_pushundefined(J);
|
|
js_rot(J, 4); /* accumulator on top */
|
|
js_rot(J, 4); /* property on top */
|
|
js_pushnumber(J, k);
|
|
js_copy(J, 0);
|
|
js_call(J, 4); /* calculate new accumulator */
|
|
}
|
|
--k;
|
|
}
|
|
|
|
/* return accumulator */
|
|
}
|
|
|
|
static void A_isArray(js_State *J)
|
|
{
|
|
if (js_isobject(J, 1)) {
|
|
js_Object *T = js_toobject(J, 1);
|
|
js_pushboolean(J, T->type == JS_CARRAY);
|
|
} else {
|
|
js_pushboolean(J, 0);
|
|
}
|
|
}
|
|
|
|
void jsB_initarray(js_State *J)
|
|
{
|
|
js_pushobject(J, J->Array_prototype);
|
|
{
|
|
jsB_propf(J, "Array.prototype.toString", Ap_toString, 0);
|
|
jsB_propf(J, "Array.prototype.concat", Ap_concat, 0); /* 1 */
|
|
jsB_propf(J, "Array.prototype.join", Ap_join, 1);
|
|
jsB_propf(J, "Array.prototype.pop", Ap_pop, 0);
|
|
jsB_propf(J, "Array.prototype.push", Ap_push, 0); /* 1 */
|
|
jsB_propf(J, "Array.prototype.reverse", Ap_reverse, 0);
|
|
jsB_propf(J, "Array.prototype.shift", Ap_shift, 0);
|
|
jsB_propf(J, "Array.prototype.slice", Ap_slice, 2);
|
|
jsB_propf(J, "Array.prototype.sort", Ap_sort, 1);
|
|
jsB_propf(J, "Array.prototype.splice", Ap_splice, 0); /* 2 */
|
|
jsB_propf(J, "Array.prototype.unshift", Ap_unshift, 0); /* 1 */
|
|
|
|
/* ES5 */
|
|
jsB_propf(J, "Array.prototype.indexOf", Ap_indexOf, 1);
|
|
jsB_propf(J, "Array.prototype.lastIndexOf", Ap_lastIndexOf, 1);
|
|
jsB_propf(J, "Array.prototype.every", Ap_every, 1);
|
|
jsB_propf(J, "Array.prototype.some", Ap_some, 1);
|
|
jsB_propf(J, "Array.prototype.forEach", Ap_forEach, 1);
|
|
jsB_propf(J, "Array.prototype.map", Ap_map, 1);
|
|
jsB_propf(J, "Array.prototype.filter", Ap_filter, 1);
|
|
jsB_propf(J, "Array.prototype.reduce", Ap_reduce, 1);
|
|
jsB_propf(J, "Array.prototype.reduceRight", Ap_reduceRight, 1);
|
|
}
|
|
js_newcconstructor(J, jsB_new_Array, jsB_new_Array, "Array", 0); /* 1 */
|
|
{
|
|
/* ES5 */
|
|
jsB_propf(J, "Array.isArray", A_isArray, 1);
|
|
}
|
|
js_defglobal(J, "Array", JS_DONTENUM);
|
|
}
|