static void Encode(js_State *J, const char *str, const char *unescaped)
{
js_Buffer *sb = NULL;
static const char *HEX = "0123456789ABCDEF";
while (*str) {
int c = (unsigned char) *str++;
if (strchr(unescaped, c))
js_putc(J, &sb, c);
else {
js_putc(J, &sb, '%');
js_putc(J, &sb, HEX[(c >> 4) & 0xf]);
js_putc(J, &sb, HEX[c & 0xf]);
}
}
js_putc(J, &sb, 0);
if (js_try(J)) {
js_free(J, sb);
js_throw(J);
}
js_pushstring(J, sb ? sb->s : "");
js_endtry(J);
js_free(J, sb);
}
static void Sp_concat(js_State *J)
{
unsigned int i, top = js_gettop(J);
unsigned int n;
char * volatile out;
const char *s;
if (top == 1)
return;
s = js_tostring(J, 0);
n = strlen(s);
out = js_malloc(J, n + 1);
strcpy(out, s);
if (js_try(J)) {
js_free(J, out);
js_throw(J);
}
for (i = 1; i < top; ++i) {
s = js_tostring(J, i);
n += strlen(s);
out = realloc(out, n + 1);
strcat(out, s);
}
js_pushstring(J, out);
js_endtry(J);
js_free(J, out);
}
void js_concat(js_State *J)
{
js_Value va = js_toprimitive(J, -2, JS_HNONE);
js_Value vb = js_toprimitive(J, -1, JS_HNONE);
if (va.type == JS_TSTRING || vb.type == JS_TSTRING) {
const char *sa = jsV_tostring(J, &va);
const char *sb = jsV_tostring(J, &vb);
char *sab = js_malloc(J, strlen(sa) + strlen(sb) + 1);
strcpy(sab, sa);
strcat(sab, sb);
if (js_try(J)) {
js_free(J, sab);
js_throw(J);
}
js_pop(J, 2);
js_pushstring(J, sab);
js_endtry(J);
js_free(J, sab);
} else {
double x = jsV_tonumber(J, &va);
double y = jsV_tonumber(J, &vb);
js_pop(J, 2);
js_pushnumber(J, x + y);
}
}
void js_concat(js_State *J)
{
js_toprimitive(J, -2, JS_HNONE);
js_toprimitive(J, -1, JS_HNONE);
if (js_isstring(J, -2) || js_isstring(J, -1)) {
const char *sa = js_tostring(J, -2);
const char *sb = js_tostring(J, -1);
/* TODO: create js_String directly */
char *sab = js_malloc(J, strlen(sa) + strlen(sb) + 1);
strcpy(sab, sa);
strcat(sab, sb);
if (js_try(J)) {
js_free(J, sab);
js_throw(J);
}
js_pop(J, 2);
js_pushstring(J, sab);
js_endtry(J);
js_free(J, sab);
} else {
double x = js_tonumber(J, -2);
double y = js_tonumber(J, -1);
js_pop(J, 2);
js_pushnumber(J, x + y);
}
}
static void Fp_toString(js_State *J)
{
js_Object *self = js_toobject(J, 0);
char *s;
unsigned int i, n;
if (!js_iscallable(J, 0))
js_typeerror(J, "not a function");
if (self->type == JS_CFUNCTION || self->type == JS_CSCRIPT) {
js_Function *F = self->u.f.function;
n = strlen("function () { ... }");
n += strlen(F->name);
for (i = 0; i < F->numparams; ++i)
n += strlen(F->vartab[i]) + 1;
s = js_malloc(J, n);
strcpy(s, "function ");
strcat(s, F->name);
strcat(s, "(");
for (i = 0; i < F->numparams; ++i) {
if (i > 0) strcat(s, ",");
strcat(s, F->vartab[i]);
}
strcat(s, ") { ... }");
if (js_try(J)) {
js_free(J, s);
js_throw(J);
}
js_pushstring(J, s);
js_free(J, s);
js_endtry(J);
} else {
js_pushliteral(J, "function () { ... }");
}
}
int js_pconstruct(js_State *J, int n)
{
if (js_try(J))
return 1;
js_construct(J, n);
js_endtry(J);
return 0;
}
int js_ploadfile(js_State *J, const char *filename)
{
if (js_try(J))
return 1;
js_loadfile(J, filename);
js_endtry(J);
return 0;
}
int js_ploadstring(js_State *J, const char *filename, const char *source)
{
if (js_try(J))
return 1;
js_loadstring(J, filename, source);
js_endtry(J);
return 0;
}
int js_pcall(js_State *J, int n)
{
if (js_try(J))
return 1;
js_call(J, n);
js_endtry(J);
return 0;
}
static void Sp_replace_string(js_State *J)
{
const char *source, *needle, *s, *r;
js_Buffer *sb = NULL;
int n;
source = js_tostring(J, 0);
needle = js_tostring(J, 1);
s = strstr(source, needle);
if (!s) {
js_copy(J, 0);
return;
}
n = strlen(needle);
if (js_iscallable(J, 2)) {
js_copy(J, 2);
js_pushglobal(J);
js_pushlstring(J, s, n); /* arg 1: substring that matched */
js_pushnumber(J, s - source); /* arg 2: offset within search string */
js_copy(J, 0); /* arg 3: search string */
js_call(J, 3);
r = js_tostring(J, -1);
js_putm(J, &sb, source, s);
js_puts(J, &sb, r);
js_puts(J, &sb, s + n);
js_putc(J, &sb, 0);
js_pop(J, 1);
} else {
r = js_tostring(J, 2);
js_putm(J, &sb, source, s);
while (*r) {
if (*r == '$') {
switch (*(++r)) {
case '$': js_putc(J, &sb, '$'); break;
case '&': js_putm(J, &sb, s, s + n); break;
case '`': js_putm(J, &sb, source, s); break;
case '\'': js_puts(J, &sb, s + n); break;
default: js_putc(J, &sb, '$'); js_putc(J, &sb, *r); break;
}
++r;
} else {
js_putc(J, &sb, *r++);
}
}
js_puts(J, &sb, s + n);
js_putc(J, &sb, 0);
}
if (js_try(J)) {
js_free(J, sb);
js_throw(J);
}
js_pushstring(J, sb ? sb->s : "");
js_endtry(J);
js_free(J, sb);
}
static void Ap_sort(js_State *J)
{
struct sortslot *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");
array = js_malloc(J, len * sizeof *array);
/* 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);
}
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_join(js_State *J)
{
char * volatile out = NULL;
const char *sep;
const char *r;
unsigned int seplen;
unsigned int k, n, len;
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);
n += strlen(r);
if (k == 0) {
out = js_malloc(J, n);
strcpy(out, r);
} else {
n += seplen;
out = realloc(out, n);
strcat(out, sep);
strcat(out, r);
}
js_pop(J, 1);
}
js_pushstring(J, out);
js_endtry(J);
js_free(J, out);
}
void js_loadfile(js_State *J, const char *filename)
{
FILE *f;
char *s;
int n, t;
f = fopen(filename, "rb");
if (!f) {
js_error(J, "cannot open file: '%s'", filename);
}
if (fseek(f, 0, SEEK_END) < 0) {
fclose(f);
js_error(J, "cannot seek in file: '%s'", filename);
}
n = ftell(f);
if (n < 0) {
fclose(f);
js_error(J, "cannot tell in file: '%s'", filename);
}
if (fseek(f, 0, SEEK_SET) < 0) {
fclose(f);
js_error(J, "cannot seek in file: '%s'", filename);
}
s = js_malloc(J, n + 1); /* add space for string terminator */
if (!s) {
fclose(f);
js_error(J, "cannot allocate storage for file contents: '%s'", filename);
}
t = fread(s, 1, n, f);
if (t != n) {
js_free(J, s);
fclose(f);
js_error(J, "cannot read data from file: '%s'", filename);
}
s[n] = 0; /* zero-terminate string containing file data */
if (js_try(J)) {
js_free(J, s);
fclose(f);
js_throw(J);
}
js_loadstring(J, filename, s);
js_free(J, s);
fclose(f);
js_endtry(J);
}
int js_dofile(js_State *J, const char *filename)
{
if (js_try(J)) {
fprintf(stderr, "libjs: %s\n", js_tostring(J, -1));
js_pop(J, 1);
return 1;
}
js_loadfile(J, filename);
js_pushglobal(J);
js_call(J, 0);
js_pop(J, 1);
js_endtry(J);
return 0;
}
int js_dostring(js_State *J, const char *source)
{
if (js_try(J)) {
fprintf(stderr, "%s\n", js_tostring(J, -1));
js_pop(J, 1);
return 1;
}
js_loadstring(J, "[string]", source);
js_pushglobal(J);
js_call(J, 0);
js_pop(J, 1);
js_endtry(J);
return 0;
}
int js_dostring(js_State *J, const char *source, int report)
{
if (js_try(J)) {
fprintf(stderr, "libjs: %s\n", js_tostring(J, -1));
js_pop(J, 1);
return 1;
}
js_loadstring(J, "(string)", source);
js_pushglobal(J);
js_call(J, 0);
if (report)
printf("%s\n", js_tostring(J, -1));
js_pop(J, 1);
js_endtry(J);
return 0;
}
static void js_loadstringx(js_State *J, const char *filename, const char *source, int iseval)
{
js_Ast *P;
js_Function *F;
if (js_try(J)) {
jsP_freeparse(J);
js_throw(J);
}
P = jsP_parse(J, filename, source);
F = jsC_compile(J, P);
jsP_freeparse(J);
js_newscript(J, F, iseval ? (J->strict ? J->E : NULL) : J->GE);
js_endtry(J);
}
void js_loadstring(js_State *J, const char *filename, const char *source)
{
js_Ast *P;
js_Function *F;
if (js_try(J)) {
jsP_freeparse(J);
js_throw(J);
}
P = jsP_parse(J, filename, source);
F = jsC_compile(J, P);
jsP_freeparse(J);
js_newscript(J, F);
js_endtry(J);
}
static void Sp_toUpperCase(js_State *J)
{
const char *src = js_tostring(J, 0);
char *dst = js_malloc(J, UTFmax * strlen(src) + 1);
const char *s = src;
char *d = dst;
Rune rune;
while (*s) {
s += chartorune(&rune, s);
rune = toupperrune(rune);
d += runetochar(d, &rune);
}
*d = 0;
if (js_try(J)) {
js_free(J, dst);
js_throw(J);
}
js_pushstring(J, dst);
js_endtry(J);
js_free(J, dst);
}
static void S_fromCharCode(js_State *J)
{
unsigned int i, top = js_gettop(J);
Rune c;
char *s, *p;
s = p = js_malloc(J, (top-1) * UTFmax + 1);
if (js_try(J)) {
js_free(J, s);
js_throw(J);
}
for (i = 1; i < top; ++i) {
c = js_touint16(J, i);
p += runetochar(p, &c);
}
*p = 0;
js_pushstring(J, s);
js_endtry(J);
js_free(J, s);
}
static void jsB_Function(js_State *J)
{
unsigned int i, top = js_gettop(J);
js_Buffer *sb = NULL;
const char *body;
js_Ast *parse;
js_Function *fun;
/* p1, p2, ..., pn */
if (top > 2) {
for (i = 1; i < top - 1; ++i) {
if (i > 1)
js_putc(J, &sb, ',');
js_puts(J, &sb, js_tostring(J, i));
}
js_putc(J, &sb, ')');
}
/* body */
body = js_isdefined(J, top - 1) ? js_tostring(J, top - 1) : "";
if (js_try(J)) {
js_free(J, sb);
jsP_freeparse(J);
js_throw(J);
}
parse = jsP_parsefunction(J, "[string]", sb ? sb->s : NULL, body);
fun = jsC_compilefunction(J, parse);
js_endtry(J);
js_free(J, sb);
jsP_freeparse(J);
js_newfunction(J, fun, J->GE);
}
static void Decode(js_State *J, const char *str, const char *reserved)
{
js_Buffer *sb = NULL;
int a, b;
while (*str) {
int c = (unsigned char) *str++;
if (c != '%')
js_putc(J, &sb, c);
else {
if (!str[0] || !str[1])
js_urierror(J, "truncated escape sequence");
a = *str++;
b = *str++;
if (!jsY_ishex(a) || !jsY_ishex(b))
js_urierror(J, "invalid escape sequence");
c = jsY_tohex(a) << 4 | jsY_tohex(b);
if (!strchr(reserved, c))
js_putc(J, &sb, c);
else {
js_putc(J, &sb, '%');
js_putc(J, &sb, a);
js_putc(J, &sb, b);
}
}
}
js_putc(J, &sb, 0);
if (js_try(J)) {
js_free(J, sb);
js_throw(J);
}
js_pushstring(J, sb ? sb->s : "");
js_endtry(J);
js_free(J, sb);
}
static void Sp_replace_regexp(js_State *J)
{
js_Regexp *re;
const char *source, *s, *r;
js_Buffer *sb = NULL;
unsigned int n, x;
Resub m;
source = js_tostring(J, 0);
re = js_toregexp(J, 1);
if (js_regexec(re->prog, source, &m, 0)) {
js_copy(J, 0);
return;
}
re->last = 0;
loop:
s = m.sub[0].sp;
n = m.sub[0].ep - m.sub[0].sp;
if (js_iscallable(J, 2)) {
js_copy(J, 2);
js_pushglobal(J);
for (x = 0; m.sub[x].sp; ++x) /* arg 0..x: substring and subexps that matched */
js_pushlstring(J, m.sub[x].sp, m.sub[x].ep - m.sub[x].sp);
js_pushnumber(J, s - source); /* arg x+2: offset within search string */
js_copy(J, 0); /* arg x+3: search string */
js_call(J, 2 + x);
r = js_tostring(J, -1);
js_putm(J, &sb, source, s);
js_puts(J, &sb, r);
js_pop(J, 1);
} else {
r = js_tostring(J, 2);
js_putm(J, &sb, source, s);
while (*r) {
if (*r == '$') {
switch (*(++r)) {
case '$': js_putc(J, &sb, '$'); break;
case '`': js_putm(J, &sb, source, s); break;
case '\'': js_puts(J, &sb, s + n); break;
case '&':
js_putm(J, &sb, s, s + n);
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
x = *r - '0';
if (r[1] >= '0' && r[1] <= '9')
x = x * 10 + *(++r) - '0';
if (x > 0 && x < m.nsub) {
js_putm(J, &sb, m.sub[x].sp, m.sub[x].ep);
} else {
js_putc(J, &sb, '$');
if (x > 10) {
js_putc(J, &sb, '0' + x / 10);
js_putc(J, &sb, '0' + x % 10);
} else {
js_putc(J, &sb, '0' + x);
}
}
break;
default:
js_putc(J, &sb, '$');
js_putc(J, &sb, *r);
break;
}
++r;
} else {
js_putc(J, &sb, *r++);
}
}
}
if (re->flags & JS_REGEXP_G) {
source = m.sub[0].ep;
if (n == 0) {
if (*source)
js_putc(J, &sb, *source++);
else
goto end;
}
if (!js_regexec(re->prog, source, &m, REG_NOTBOL))
goto loop;
}
end:
js_puts(J, &sb, s + n);
js_putc(J, &sb, 0);
if (js_try(J)) {
js_free(J, sb);
js_throw(J);
}
js_pushstring(J, sb ? sb->s : "");
js_endtry(J);
js_free(J, sb);
}
static void jsR_run(js_State *J, js_Function *F)
{
js_Function **FT = F->funtab;
double *NT = F->numtab;
const char **ST = F->strtab;
js_Instruction *pcstart = F->code;
js_Instruction *pc = F->code;
enum js_OpCode opcode;
int offset;
const char *str;
js_Object *obj;
double x, y;
unsigned int ux, uy;
int ix, iy, okay;
int b;
while (1) {
if (J->gccounter > JS_GCLIMIT) {
J->gccounter = 0;
js_gc(J, 0);
}
opcode = *pc++;
switch (opcode) {
case OP_POP: js_pop(J, 1); break;
case OP_DUP: js_dup(J); break;
case OP_DUP2: js_dup2(J); break;
case OP_ROT2: js_rot2(J); break;
case OP_ROT3: js_rot3(J); break;
case OP_ROT4: js_rot4(J); break;
case OP_NUMBER_0: js_pushnumber(J, 0); break;
case OP_NUMBER_1: js_pushnumber(J, 1); break;
case OP_NUMBER_POS: js_pushnumber(J, *pc++); break;
case OP_NUMBER_NEG: js_pushnumber(J, -(*pc++)); break;
case OP_NUMBER: js_pushnumber(J, NT[*pc++]); break;
case OP_STRING: js_pushliteral(J, ST[*pc++]); break;
case OP_CLOSURE: js_newfunction(J, FT[*pc++], J->E); break;
case OP_NEWOBJECT: js_newobject(J); break;
case OP_NEWARRAY: js_newarray(J); break;
case OP_NEWREGEXP: js_newregexp(J, ST[pc[0]], pc[1]); pc += 2; break;
case OP_UNDEF: js_pushundefined(J); break;
case OP_NULL: js_pushnull(J); break;
case OP_TRUE: js_pushboolean(J, 1); break;
case OP_FALSE: js_pushboolean(J, 0); break;
case OP_THIS: js_copy(J, 0); break;
case OP_GLOBAL: js_pushobject(J, J->G); break;
case OP_CURRENT: js_currentfunction(J); break;
case OP_INITLOCAL:
STACK[BOT + *pc++] = STACK[--TOP];
break;
case OP_GETLOCAL:
CHECKSTACK(1);
STACK[TOP++] = STACK[BOT + *pc++];
break;
case OP_SETLOCAL:
STACK[BOT + *pc++] = STACK[TOP-1];
break;
case OP_DELLOCAL:
++pc;
js_pushboolean(J, 0);
break;
case OP_INITVAR:
js_initvar(J, ST[*pc++], -1);
js_pop(J, 1);
break;
case OP_DEFVAR:
js_defvar(J, ST[*pc++]);
break;
case OP_GETVAR:
str = ST[*pc++];
if (!js_hasvar(J, str))
js_referenceerror(J, "'%s' is not defined", str);
break;
case OP_HASVAR:
if (!js_hasvar(J, ST[*pc++]))
js_pushundefined(J);
break;
case OP_SETVAR:
js_setvar(J, ST[*pc++]);
break;
case OP_DELVAR:
b = js_delvar(J, ST[*pc++]);
js_pushboolean(J, b);
break;
case OP_IN:
str = js_tostring(J, -2);
if (!js_isobject(J, -1))
js_typeerror(J, "operand to 'in' is not an object");
b = js_hasproperty(J, -1, str);
js_pop(J, 2 + b);
js_pushboolean(J, b);
break;
case OP_INITPROP:
obj = js_toobject(J, -3);
str = js_tostring(J, -2);
jsR_setproperty(J, obj, str, stackidx(J, -1));
js_pop(J, 2);
break;
case OP_INITGETTER:
obj = js_toobject(J, -3);
str = js_tostring(J, -2);
jsR_defproperty(J, obj, str, 0, NULL, jsR_tofunction(J, -1), NULL);
js_pop(J, 2);
break;
case OP_INITSETTER:
obj = js_toobject(J, -3);
str = js_tostring(J, -2);
jsR_defproperty(J, obj, str, 0, NULL, NULL, jsR_tofunction(J, -1));
js_pop(J, 2);
break;
case OP_GETPROP:
str = js_tostring(J, -1);
obj = js_toobject(J, -2);
jsR_getproperty(J, obj, str);
js_rot3pop2(J);
break;
case OP_GETPROP_S:
str = ST[*pc++];
obj = js_toobject(J, -1);
jsR_getproperty(J, obj, str);
js_rot2pop1(J);
break;
case OP_SETPROP:
str = js_tostring(J, -2);
obj = js_toobject(J, -3);
jsR_setproperty(J, obj, str, stackidx(J, -1));
js_rot3pop2(J);
break;
case OP_SETPROP_S:
str = ST[*pc++];
obj = js_toobject(J, -2);
jsR_setproperty(J, obj, str, stackidx(J, -1));
js_rot2pop1(J);
break;
case OP_DELPROP:
str = js_tostring(J, -1);
obj = js_toobject(J, -2);
b = jsR_delproperty(J, obj, str);
js_pop(J, 2);
js_pushboolean(J, b);
break;
case OP_DELPROP_S:
str = ST[*pc++];
obj = js_toobject(J, -1);
b = jsR_delproperty(J, obj, str);
js_pop(J, 1);
js_pushboolean(J, b);
break;
case OP_ITERATOR:
if (!js_isundefined(J, -1) && !js_isnull(J, -1)) {
obj = jsV_newiterator(J, js_toobject(J, -1), 0);
js_pop(J, 1);
js_pushobject(J, obj);
}
break;
case OP_NEXTITER:
obj = js_toobject(J, -1);
str = jsV_nextiterator(J, obj);
if (str) {
js_pushliteral(J, str);
js_pushboolean(J, 1);
} else {
js_pop(J, 1);
js_pushboolean(J, 0);
}
break;
/* Function calls */
case OP_EVAL:
js_eval(J);
break;
case OP_CALL:
js_call(J, *pc++);
break;
case OP_NEW:
js_construct(J, *pc++);
break;
/* Unary operators */
case OP_TYPEOF:
str = js_typeof(J, -1);
js_pop(J, 1);
js_pushliteral(J, str);
break;
case OP_POS:
x = js_tonumber(J, -1);
js_pop(J, 1);
js_pushnumber(J, x);
break;
case OP_NEG:
x = js_tonumber(J, -1);
js_pop(J, 1);
js_pushnumber(J, -x);
break;
case OP_BITNOT:
ix = js_toint32(J, -1);
js_pop(J, 1);
js_pushnumber(J, ~ix);
break;
case OP_LOGNOT:
b = js_toboolean(J, -1);
js_pop(J, 1);
js_pushboolean(J, !b);
break;
case OP_INC:
x = js_tonumber(J, -1);
js_pop(J, 1);
js_pushnumber(J, x + 1);
break;
case OP_DEC:
x = js_tonumber(J, -1);
js_pop(J, 1);
js_pushnumber(J, x - 1);
break;
case OP_POSTINC:
x = js_tonumber(J, -1);
js_pop(J, 1);
js_pushnumber(J, x + 1);
js_pushnumber(J, x);
break;
case OP_POSTDEC:
x = js_tonumber(J, -1);
js_pop(J, 1);
js_pushnumber(J, x - 1);
js_pushnumber(J, x);
break;
/* Multiplicative operators */
case OP_MUL:
x = js_tonumber(J, -2);
y = js_tonumber(J, -1);
js_pop(J, 2);
js_pushnumber(J, x * y);
break;
case OP_DIV:
x = js_tonumber(J, -2);
y = js_tonumber(J, -1);
js_pop(J, 2);
js_pushnumber(J, x / y);
break;
case OP_MOD:
x = js_tonumber(J, -2);
y = js_tonumber(J, -1);
js_pop(J, 2);
js_pushnumber(J, fmod(x, y));
break;
/* Additive operators */
case OP_ADD:
js_concat(J);
break;
case OP_SUB:
x = js_tonumber(J, -2);
y = js_tonumber(J, -1);
js_pop(J, 2);
js_pushnumber(J, x - y);
break;
/* Shift operators */
case OP_SHL:
ix = js_toint32(J, -2);
uy = js_touint32(J, -1);
js_pop(J, 2);
js_pushnumber(J, ix << (uy & 0x1F));
break;
case OP_SHR:
ix = js_toint32(J, -2);
uy = js_touint32(J, -1);
js_pop(J, 2);
js_pushnumber(J, ix >> (uy & 0x1F));
break;
case OP_USHR:
ux = js_touint32(J, -2);
uy = js_touint32(J, -1);
js_pop(J, 2);
js_pushnumber(J, ux >> (uy & 0x1F));
break;
/* Relational operators */
case OP_LT: b = js_compare(J, &okay); js_pop(J, 2); js_pushboolean(J, okay && b < 0); break;
case OP_GT: b = js_compare(J, &okay); js_pop(J, 2); js_pushboolean(J, okay && b > 0); break;
case OP_LE: b = js_compare(J, &okay); js_pop(J, 2); js_pushboolean(J, okay && b <= 0); break;
case OP_GE: b = js_compare(J, &okay); js_pop(J, 2); js_pushboolean(J, okay && b >= 0); break;
case OP_INSTANCEOF:
b = js_instanceof(J);
js_pop(J, 2);
js_pushboolean(J, b);
break;
/* Equality */
case OP_EQ: b = js_equal(J); js_pop(J, 2); js_pushboolean(J, b); break;
case OP_NE: b = js_equal(J); js_pop(J, 2); js_pushboolean(J, !b); break;
case OP_STRICTEQ: b = js_strictequal(J); js_pop(J, 2); js_pushboolean(J, b); break;
case OP_STRICTNE: b = js_strictequal(J); js_pop(J, 2); js_pushboolean(J, !b); break;
case OP_JCASE:
offset = *pc++;
b = js_strictequal(J);
if (b) {
js_pop(J, 2);
pc = pcstart + offset;
} else {
js_pop(J, 1);
}
break;
/* Binary bitwise operators */
case OP_BITAND:
ix = js_toint32(J, -2);
iy = js_toint32(J, -1);
js_pop(J, 2);
js_pushnumber(J, ix & iy);
break;
case OP_BITXOR:
ix = js_toint32(J, -2);
iy = js_toint32(J, -1);
js_pop(J, 2);
js_pushnumber(J, ix ^ iy);
break;
case OP_BITOR:
ix = js_toint32(J, -2);
iy = js_toint32(J, -1);
js_pop(J, 2);
js_pushnumber(J, ix | iy);
break;
/* Try and Catch */
case OP_THROW:
js_throw(J);
case OP_TRY:
offset = *pc++;
if (js_trypc(J, pc)) {
pc = J->trybuf[J->trytop].pc;
} else {
pc = pcstart + offset;
}
break;
case OP_ENDTRY:
js_endtry(J);
break;
case OP_CATCH:
str = ST[*pc++];
obj = jsV_newobject(J, JS_COBJECT, NULL);
js_pushobject(J, obj);
js_rot2(J);
js_setproperty(J, -2, str);
J->E = jsR_newenvironment(J, obj, J->E);
js_pop(J, 1);
break;
case OP_ENDCATCH:
J->E = J->E->outer;
break;
/* With */
case OP_WITH:
obj = js_toobject(J, -1);
J->E = jsR_newenvironment(J, obj, J->E);
js_pop(J, 1);
break;
case OP_ENDWITH:
J->E = J->E->outer;
break;
/* Branching */
case OP_DEBUGGER:
js_trap(J, (int)(pc - pcstart) - 1);
break;
case OP_JUMP:
pc = pcstart + *pc;
break;
case OP_JTRUE:
offset = *pc++;
b = js_toboolean(J, -1);
js_pop(J, 1);
if (b)
pc = pcstart + offset;
break;
case OP_JFALSE:
offset = *pc++;
b = js_toboolean(J, -1);
js_pop(J, 1);
if (!b)
pc = pcstart + offset;
break;
case OP_RETURN:
return;
case OP_LINE:
J->trace[J->tracetop].line = *pc++;
break;
}
}
}