JS_ArenaAllocate(JSArenaPool *pool, size_t nb)
{
JSArena **ap, *a, *b;
jsuword extra, hdrsz, gross;
void *p;
/*
* Search pool from current forward till we find or make enough space.
*
* NB: subtract nb from a->limit in the loop condition, instead of adding
* nb to a->avail, to avoid overflowing a 32-bit address space (possible
* when running a 32-bit program on a 64-bit system where the kernel maps
* the heap up against the top of the 32-bit address space).
*
* Thanks to Juergen Kreileder <*****@*****.**>, who brought this up in
* https://bugzilla.mozilla.org/show_bug.cgi?id=279273.
*/
JS_ASSERT((nb & pool->mask) == 0);
for (a = pool->current; nb > a->limit || a->avail > a->limit - nb;
pool->current = a) {
ap = &a->next;
if (!*ap) {
/* Not enough space in pool, so we must malloc. */
extra = (nb > pool->arenasize) ? HEADER_SIZE(pool) : 0;
hdrsz = sizeof *a + extra + pool->mask;
gross = hdrsz + JS_MAX(nb, pool->arenasize);
if (gross < nb)
return NULL;
if (pool->quotap) {
if (gross > *pool->quotap)
return NULL;
b = (JSArena *) js_malloc(gross);
if (!b)
return NULL;
*pool->quotap -= gross;
} else {
b = (JSArena *) js_malloc(gross);
if (!b)
return NULL;
}
b->next = NULL;
b->limit = (jsuword)b + gross;
JS_COUNT_ARENA(pool,++);
COUNT(pool, nmallocs);
/* If oversized, store ap in the header, just before a->base. */
*ap = a = b;
JS_ASSERT(gross <= JS_UPTRDIFF(a->limit, a));
if (extra) {
a->base = a->avail =
((jsuword)a + hdrsz) & ~HEADER_BASE_MASK(pool);
SET_HEADER(pool, a, ap);
} else {
a->base = a->avail = JS_ARENA_ALIGN(pool, a + 1);
}
continue;
}
a = *ap; /* move to next arena */
}
static Function *
link_code (JSVirtualMachine *vm, unsigned char *code, unsigned int code_len,
unsigned int consts_offset)
{
unsigned char *cp, *end;
JSInt32 i;
Compiled **reloc;
unsigned int cpos;
Function *f;
unsigned char *fixed_code;
/* Terminate the code with op `done'. */
fixed_code = js_malloc (vm, code_len + 1);
memcpy (fixed_code, code, code_len);
fixed_code[code_len] = 1; /* op `done' */
cp = fixed_code;
end = fixed_code + code_len + 1;
/* Alloc function closure. */
f = js_vm_alloc_destroyable (vm, sizeof (*f));
f->destroy = function_destroy;
/* Allocate space for our compiled code. <length> is enought. */
f->code = js_malloc (vm, (code_len + 1) * sizeof (Compiled));
reloc = js_calloc (vm, code_len + 1, sizeof (Compiled *));
/* Link phase 1: constants and symbols. */
cpos = 0;
while (cp < end)
{
switch (*cp++)
{
/* include c1switch.h */
#include "c1switch.h"
/* end include c1switch.h */
}
}
f->length = cpos;
/* Link phase 2: relative jumps. */
cp = fixed_code;
cpos = 0;
while (cp < end)
{
switch (*cp++)
{
/* include c2switch.h */
#include "c2switch.h"
/* end include c2switch.h */
}
}
/* Handle debug info. */
/* XXX */
js_free (reloc);
js_free (fixed_code);
return f;
}
bool
StructuredCloneData::Copy(const StructuredCloneData& aData)
{
if (!aData.mData) {
return true;
}
uint64_t* data = static_cast<uint64_t*>(js_malloc(aData.mDataLength));
if (!data) {
return false;
}
memcpy(data, aData.mData, aData.mDataLength);
mData = data;
mDataLength = aData.mDataLength;
mDataOwned = eJSAllocated;
MOZ_ASSERT(BlobImpls().IsEmpty());
BlobImpls().AppendElements(aData.BlobImpls());
MOZ_ASSERT(GetImages().IsEmpty());
return true;
}
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 () { ... }");
}
}
void* js_realloc(void* p, size_t bytes) {
if (!p) {
return js_malloc(bytes);
}
if (!bytes) {
js_free(p);
return nullptr;
}
size_t current = mongo::sm::get_current(p);
if (current >= bytes) {
return p;
}
size_t tb = mongo::sm::total_bytes;
if (tb >= current) {
mongo::sm::total_bytes = tb - current;
}
return mongo::sm::wrap_alloc(
[](void* ptr, size_t b) { return std::realloc(ptr, b); }, p, bytes);
}
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);
}
}
unsigned int js_vm_intern_with_len(JSVirtualMachine * vm, const char *name, unsigned int len)
{
JSHashBucket *b;
unsigned int pos = js_count_hash(name, len) % JS_HASH_TABLE_SIZE;
for (b = vm->globals_hash[pos]; b; b = b->next)
if (strcmp(b->name, name) == 0)
return b->u.ui;
b = js_malloc(vm, sizeof(*b));
b->name = js_strdup(vm, name);
b->next = vm->globals_hash[pos];
vm->globals_hash[pos] = b;
/* Alloc space from the globals array. */
if (vm->num_globals >= vm->globals_alloc) {
// CHANGE alloc times to 16
vm->globals = js_realloc(vm, vm->globals, (vm->globals_alloc + 16) * sizeof(JSNode));
vm->globals_alloc += 16;
}
/* Initialize symbol's name spaces. */
vm->globals[vm->num_globals].type = JS_UNDEFINED;
b->u.ui = vm->num_globals++;
return b->u.ui;
}
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);
}
}
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);
}
bool
StructuredCloneData::ReadIPCParams(const IPC::Message* aMsg,
void** aIter)
{
MOZ_ASSERT(!mData);
if (!ReadParam(aMsg, aIter, &mDataLength)) {
return false;
}
if (!mDataLength) {
return true;
}
const char** buffer =
const_cast<const char**>(reinterpret_cast<char**>(&mData));
// Structured clone data must be 64-bit aligned.
if (!aMsg->ReadBytes(aIter, buffer, mDataLength, sizeof(uint64_t))) {
return false;
}
uint64_t* data = static_cast<uint64_t*>(js_malloc(mDataLength));
if (!data) {
return false;
}
memcpy(data, mData, mDataLength);
mData = data;
mDataOwned = eJSAllocated;
return true;
}
static void textinit(js_State *J)
{
if (!J->lexbuf.text) {
J->lexbuf.cap = 4096;
J->lexbuf.text = js_malloc(J, J->lexbuf.cap);
}
J->lexbuf.len = 0;
}
static void addjump(JF, enum js_AstType type, js_Ast *target, int inst)
{
js_JumpList *jump = js_malloc(J, sizeof *jump);
jump->type = type;
jump->inst = inst;
jump->next = target->jumps;
target->jumps = jump;
}
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);
}
js_String *jsV_newmemstring(js_State *J, const char *s, int n)
{
js_String *v = js_malloc(J, offsetof(js_String, p) + n + 1);
memcpy(v->p, s, n);
v->p[n] = 0;
v->gcmark = 0;
v->gcnext = J->gcstr;
J->gcstr = v;
++J->gccounter;
return v;
}
js_Environment *jsR_newenvironment(js_State *J, js_Object *vars, js_Environment *outer)
{
js_Environment *E = js_malloc(J, sizeof *E);
E->gcmark = 0;
E->gcnext = J->gcenv;
J->gcenv = E;
++J->gccounter;
E->outer = outer;
E->variables = vars;
return E;
}
char* js_strdup(const char* s) {
size_t bytes = std::strlen(s) + 1;
char* new_s = static_cast<char*>(js_malloc(bytes));
if (!new_s) {
return nullptr;
}
std::memcpy(new_s, s, bytes);
return new_s;
}
static js_Property *newproperty(js_State *J, js_Object *obj, const char *name)
{
js_Property *node = js_malloc(J, sizeof *node);
node->name = js_intern(J, name);
node->left = node->right = &sentinel;
node->level = 1;
node->atts = 0;
node->value.type = JS_TUNDEFINED;
node->value.u.number = 0;
node->getter = NULL;
node->setter = NULL;
++obj->count;
return node;
}
bool
StructuredCloneData::CopyExternalData(const void* aData,
size_t aDataLength)
{
MOZ_ASSERT(!mData);
uint64_t* data = static_cast<uint64_t*>(js_malloc(aDataLength));
if (!data) {
return false;
}
memcpy(data, aData, aDataLength);
mData = data;
mDataLength = aDataLength;
mDataOwned = eJSAllocated;
return true;
}
BumpChunk *
BumpChunk::new_(size_t chunkSize)
{
JS_ASSERT(RoundUpPow2(chunkSize) == chunkSize);
void *mem = js_malloc(chunkSize);
if (!mem)
return NULL;
BumpChunk *result = new (mem) BumpChunk(chunkSize - sizeof(BumpChunk));
/*
* We assume that the alignment of sAlign is less than that of
* the underlying memory allocator -- creating a new BumpChunk should
* always satisfy the sAlign alignment constraint.
*/
JS_ASSERT(AlignPtr(result->bump) == result->bump);
return result;
}
js_Object *jsV_newobject(js_State *J, enum js_Class type, js_Object *prototype)
{
js_Object *obj = js_malloc(J, sizeof *obj);
memset(obj, 0, sizeof *obj);
obj->gcmark = 0;
obj->gcnext = J->gcobj;
J->gcobj = obj;
++J->gccounter;
obj->type = type;
obj->properties = &sentinel;
obj->head = NULL;
obj->tailp = &obj->head;
obj->prototype = prototype;
obj->extensible = 1;
return obj;
}
static js_Function *newfun(js_State *J, js_Ast *name, js_Ast *params, js_Ast *body, int script)
{
js_Function *F = js_malloc(J, sizeof *F);
memset(F, 0, sizeof *F);
F->gcmark = 0;
F->gcnext = J->gcfun;
J->gcfun = F;
++J->gccounter;
F->filename = js_intern(J, J->filename);
F->line = name ? name->line : params ? params->line : body ? body->line : 1;
F->script = script;
F->name = name ? name->string : "";
cfunbody(J, F, name, params, body);
return F;
}
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);
}
JSVirtualMachine *js_vm_create(
unsigned int stack_size
#ifdef JS_RUNTIME_WARNING
, unsigned int verbose
#endif
#ifdef JS_RUNTIME_DEBUG
, int stacktrace_on_error
#endif
#ifdef JS_IOSTREAM
, JSIOStream * s_stdin, JSIOStream * s_stdout, JSIOStream * s_stderr
#endif
) {
JSVirtualMachine *vm;
vm = js_calloc(NULL, 1, sizeof(*vm));
if (vm == NULL)
return NULL;
#ifdef JS_RUNTIME_WARNING
vm->verbose = verbose;
vm->warn_undef = 1;
#endif
#ifdef JS_RUNTIME_DEBUG
vm->stacktrace_on_error = stacktrace_on_error;
#endif
/* Set the system streams. */
#ifdef JS_IOSTREAM
vm->s_stdin = s_stdin;
vm->s_stdout = s_stdout;
vm->s_stderr = s_stderr;
#endif
/* Resolve the dispatch method. */
vm->dispatch_execute = js_vm_switch0_exec;
#ifdef JS_RUNTIME_DEBUG
vm->dispatch_func_name = js_vm_switch0_func_name;
vm->dispatch_debug_position = js_vm_switch0_debug_position;
#endif
vm->stack_size = stack_size;
vm->stack = js_malloc(NULL, vm->stack_size * sizeof(*vm->stack));
if (vm->stack == NULL) {
js_free(vm);
return NULL;
}
/* Set the initial stack pointer. */
vm->sp = vm->stack + vm->stack_size - 1;
vm->gc.trigger = GC_TRIGGER;
/* We need a toplevel here. */
{
JSErrorHandlerFrame handler;
int result = 1;
memset(&handler, 0, sizeof(handler));
handler.next = vm->error_handler;
vm->error_handler = &handler;
if (setjmp(vm->error_handler->error_jmp))
/* An error occurred. */
result = 0;
else {
/* Intern some commonly used symbols. */
vm->syms.s___proto__ = js_vm_intern(vm, "__proto__");
vm->syms.s_prototype = js_vm_intern(vm, "prototype");
vm->syms.s_toSource = js_vm_intern(vm, "toSource");
vm->syms.s_toString = js_vm_intern(vm, "toString");
vm->syms.s_valueOf = js_vm_intern(vm, "valueOf");
/* Intern system built-in objects. */
intern_builtins(vm);
}
/* Pop the error handler. */
vm->error_handler = vm->error_handler->next;
if (result == 0) {
/* Argh, the initialization failed. */
js_vm_destroy(vm);
return NULL;
}
}
return vm;
}
/* Method proc. */
static int
method (JSVirtualMachine *vm, JSBuiltinInfo *builtin_info,
void *instance_context, JSSymbol method,
JSNode *result_return, JSNode *args)
{
CursesCtx *ctx = builtin_info->obj_context;
char *cp;
/* The default result. */
result_return->type = JS_BOOLEAN;
result_return->u.vboolean = 1;
if (method == ctx->s_addstr)
{
if (args->u.vinteger != 1)
goto argument_error;
if (args[1].type != JS_STRING)
goto argument_type_error;
cp = js_string_to_c_string (vm, &args[1]);
addstr (cp);
js_free (cp);
}
/* ********************************************************************** */
else if (method == ctx->s_attron)
{
if (args->u.vinteger != 1)
goto argument_error;
if (args[1].type != JS_INTEGER)
goto argument_type_error;
attron (args[1].u.vinteger);
}
/* ********************************************************************** */
else if (method == ctx->s_attroff)
{
if (args->u.vinteger != 1)
goto argument_error;
if (args[1].type != JS_INTEGER)
goto argument_type_error;
attroff (args[1].u.vinteger);
}
/* ********************************************************************** */
else if (method == ctx->s_beep)
{
if (args->u.vinteger != 0)
goto argument_error;
beep ();
}
/* ********************************************************************** */
else if (method == ctx->s_cbreak)
{
if (args->u.vinteger != 0)
goto argument_error;
cbreak ();
}
/* ********************************************************************** */
else if (method == ctx->s_clear)
{
if (args->u.vinteger != 0)
goto argument_error;
clear ();
}
/* ********************************************************************** */
else if (method == ctx->s_clrtobot)
{
if (args->u.vinteger != 0)
goto argument_error;
clrtobot ();
}
/* ********************************************************************** */
else if (method == ctx->s_clrtoeol)
{
if (args->u.vinteger != 0)
goto argument_error;
clrtoeol ();
}
/* ********************************************************************** */
else if (method == ctx->s_echo)
{
if (args->u.vinteger != 0)
goto argument_error;
echo ();
}
/* ********************************************************************** */
else if (method == ctx->s_endwin)
{
if (args->u.vinteger != 0)
goto argument_error;
endwin ();
}
/* ********************************************************************** */
else if (method == ctx->s_getch)
{
if (args->u.vinteger != 0)
goto argument_error;
result_return->type = JS_INTEGER;
result_return->u.vinteger = getch ();
}
/* ********************************************************************** */
else if (method == ctx->s_initscr)
{
if (args->u.vinteger != 0)
goto argument_error;
if (initscr () == (WINDOW *) ERR)
result_return->u.vboolean = 0;
}
/* ********************************************************************** */
else if (method == ctx->s_keypad)
{
if (args->u.vinteger != 1)
goto argument_error;
if (args[1].type != JS_BOOLEAN)
goto argument_type_error;
keypad (stdscr, args->u.vboolean);
}
/* ********************************************************************** */
else if (method == ctx->s_move)
{
if (args->u.vinteger != 2)
goto argument_error;
if (args[1].type != JS_INTEGER || args[2].type != JS_INTEGER)
goto argument_type_error;
move (args[1].u.vinteger, args[2].u.vinteger);
}
/* ********************************************************************** */
else if (method == ctx->s_mvaddstr)
{
if (args->u.vinteger != 3)
goto argument_error;
if (args[1].type != JS_INTEGER || args[2].type != JS_INTEGER
|| args[3].type != JS_STRING)
goto argument_type_error;
cp = js_string_to_c_string (vm, &args[3]);
mvaddstr (args[1].u.vinteger, args[2].u.vinteger, cp);
js_free (cp);
}
/* ********************************************************************** */
else if (method == ctx->s_mvaddsubstr)
{
int start, length;
if (args->u.vinteger != 4 && args->u.vinteger != 5)
goto argument_error;
if (args[1].type != JS_INTEGER || args[2].type != JS_INTEGER
|| args[3].type != JS_STRING
|| args[4].type != JS_INTEGER)
goto argument_type_error;
start = args[4].u.vinteger;
if (args->u.vinteger == 5)
{
if (args[5].type != JS_INTEGER)
goto argument_type_error;
length = args[5].u.vinteger;
if (length < 0)
length = 0;
}
else
length = args[3].u.vstring->len;
if (start < 0)
start += args[3].u.vstring->len;
if (start < 0)
start = 0;
if (start > args[3].u.vstring->len)
start = args[3].u.vstring->len;
if (start + length > args[3].u.vstring->len)
length = args[3].u.vstring->len - start;
cp = js_malloc (vm, length + 1);
memcpy (cp, args[3].u.vstring->data + start, length);
cp[length] = '\0';
mvaddstr (args[1].u.vinteger, args[2].u.vinteger, cp);
js_free (cp);
}
/* ********************************************************************** */
else if (method == ctx->s_mvgetch)
{
if (args->u.vinteger != 2)
goto argument_error;
if (args[1].type != JS_INTEGER || args[2].type != JS_INTEGER)
goto argument_type_error;
result_return->type = JS_INTEGER;
result_return->u.vinteger = mvgetch (args[1].u.vinteger,
args[2].u.vinteger);
}
/* ********************************************************************** */
else if (method == ctx->s_nocbreak)
{
if (args->u.vinteger != 0)
goto argument_error;
nocbreak ();
}
/* ********************************************************************** */
else if (method == ctx->s_noecho)
{
if (args->u.vinteger != 0)
goto argument_error;
noecho ();
}
/* ********************************************************************** */
else if (method == ctx->s_refresh)
{
if (args->u.vinteger != 0)
goto argument_error;
refresh ();
}
/* ********************************************************************** */
else if (method == ctx->s_standend)
{
if (args->u.vinteger != 0)
goto argument_error;
standend ();
}
/* ********************************************************************** */
else if (method == ctx->s_standout)
{
if (args->u.vinteger != 0)
goto argument_error;
standout ();
}
/* ********************************************************************** */
else if (method == vm->syms.s_toString)
{
if (args->u.vinteger != 0)
goto argument_error;
js_vm_make_static_string (vm, result_return, "Curses", 6);
}
/* ********************************************************************** */
else
return JS_PROPERTY_UNKNOWN;
return JS_PROPERTY_FOUND;
/*
* Error handling.
*/
argument_error:
sprintf (vm->error, "Curses.%s(): illegal amount of arguments",
js_vm_symname (vm, method));
js_vm_error (vm);
argument_type_error:
sprintf (vm->error, "Curses.%s(): illegal argument",
js_vm_symname (vm, method));
js_vm_error (vm);
/* NOTREACHED. */
return 0;
}
VIXL_ASSERT((static_cast<int32_t>(-1) >> 1) == -1);
VIXL_ASSERT((static_cast<uint32_t>(-1) >> 1) == 0x7FFFFFFF);
// Set up the decoder.
decoder_ = decoder;
decoder_->AppendVisitor(this);
stream_ = stream;
print_disasm_ = js_new<PrintDisassembler>(stream_);
set_coloured_trace(false);
trace_parameters_ = LOG_NONE;
ResetState();
// Allocate and set up the simulator stack.
stack_ = (byte*)js_malloc(stack_size_);
stack_limit_ = stack_ + stack_protection_size_;
// Configure the starting stack pointer.
// - Find the top of the stack.
byte * tos = stack_ + stack_size_;
// - There's a protection region at both ends of the stack.
tos -= stack_protection_size_;
// - The stack pointer must be 16-byte aligned.
tos = AlignDown(tos, 16);
set_sp(tos);
// Set the sample period to 10, as the VIXL examples and tests are short.
instrumentation_ = js_new<Instrument>("vixl_stats.csv", 10);
// Print a warning about exclusive-access instructions, but only the first
// time they are encountered. This warning can be silenced using
int
js_vm_switch0_exec (JSVirtualMachine *vm, JSByteCode *bc,
JSSymtabEntry *symtab,
unsigned int num_symtab_entries,
unsigned int consts_offset,
unsigned int anonymous_function_offset,
/*unsigned char *debug_info, unsigned int debug_info_len,*/
JSNode *object, JSNode *func,
unsigned int argc, JSNode *argv)
{
int i;
unsigned int ui;
Function *global_f = NULL;
Function *f;
unsigned char *code = NULL;
char buf[512];
if (bc)
{
/* Executing byte-code. */
/* Find the code section. */
for (i = 0; i < bc->num_sects; i++)
if (bc->sects[i].type == JS_BCST_CODE)
code = bc->sects[i].data;
assert (code != NULL);
/* Enter all functions to the known functions of the VM. */
for (i = 0; i < num_symtab_entries; i++)
{
/* Need one function. */
f = js_vm_alloc_destroyable (vm, sizeof (*f));
f->destroy = function_destroy;
f->name = js_strdup (vm, symtab[i].name);
f->length = symtab[i + 1].offset - symtab[i].offset + 1;
f->code = js_malloc (vm, f->length);
memcpy (f->code, code + symtab[i].offset, f->length - 1);
f->code[f->length - 1] = 1; /* op `done' */
/* Link the code to our environment. */
link_code (vm, f->code, f->length, consts_offset);
if (strcmp (symtab[i].name, JS_GLOBAL_NAME) == 0)
global_f = f;
else
{
int is_anonymous = 0;
/* Check for the anonymous function. */
if (symtab[i].name[0] == '.' && symtab[i].name[1] == 'F'
&& symtab[i].name[2] == ':')
is_anonymous = 1;
if (vm->verbose > 3)
{
sprintf_P (buf, vmswt0_string_0,
symtab[i].name, symtab[i].offset,
symtab[i + 1].offset - symtab[i].offset);
if (is_anonymous)
sprintf_P (buf + strlen (buf), vmswt0_string_1,
anonymous_function_offset);
strcat (buf, JS_HOST_LINE_BREAK);
//js_iostream_write (vm->s_stderr, buf, strlen (buf));
}
if (is_anonymous)
{
sprintf (buf, ".F:%u",
(unsigned int) atoi (symtab[i].name + 3)
+ anonymous_function_offset);
ui = js_vm_intern (vm, buf);
}
else
ui = js_vm_intern (vm, symtab[i].name);
vm->globals[ui].type = JS_FUNC;
vm->globals[ui].u.vfunction = js_vm_make_function (vm, f);
}
}
}
else
{
/* Applying arguments to function. */
if (func->type != JS_FUNC)
{
sprintf_P (vm->error, vmswt0_string_2);
return 0;
}
if (vm->verbose > 1)
{
sprintf_P (buf, vmswt0_string_3, JS_HOST_LINE_BREAK);
//js_iostream_write (vm->s_stderr, buf, strlen (buf));
}
f = func->u.vfunction->implementation;
execute_code (vm, object, f, argc, argv);
}
if (global_f)
{
if (vm->verbose > 1)
{
sprintf_P (buf, vmswt0_string_4, global_f->name, JS_HOST_LINE_BREAK);
//js_iostream_write (vm->s_stderr, buf, strlen (buf));
}
/* Execute. */
execute_code (vm, NULL, global_f, 0, NULL);
}
return 1;
}
explicit IdentifierToken(const char* name) {
size_t size = strlen(name) + 1;
value_ = (char*)js_malloc(size);
strncpy(value_, name, size);
}