/*
* High precission time. If an optional array is given
* it returns the difference.
*/
static duk_ret_t time_hrtime(duk_context* ctx) {
uint64_t t = sjs_time_hrtime();
uint64_t sec;
uint64_t nsec;
if (duk_is_array(ctx, 0)) {
uint64_t t0;
uint64_t sec0;
uint64_t nsec0;
duk_get_prop_index(ctx, 0, 0);
sec0 = duk_require_uint(ctx, -1);
duk_pop(ctx);
duk_get_prop_index(ctx, 0, 1);
nsec0 = duk_require_uint(ctx, -1);
duk_pop(ctx);
t0 = sec0 * NANOS_PER_SEC + nsec0;
t -= t0;
}
sec = t / NANOS_PER_SEC;
nsec = t % NANOS_PER_SEC;
duk_push_array(ctx);
duk_push_uint(ctx, sec);
duk_put_prop_index(ctx, -2, 0);
duk_push_uint(ctx, nsec);
duk_put_prop_index(ctx, -2, 1);
return 1;
}
static int
es_gumbo_node_childs(duk_context *ctx)
{
es_gumbo_node_t *egn = es_get_native_obj(ctx, 0, &es_native_gumbo_node);
int all = duk_get_boolean(ctx, 1);
const GumboNode *node = egn->node;
duk_push_array(ctx);
if(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE) {
const GumboElement *e = &node->v.element;
int num = 0;
for(int i = 0; i < e->children.length; i++) {
GumboNode *child = e->children.data[i];
if(child->type == GUMBO_NODE_WHITESPACE)
continue;
if(!all) {
if(child->type == GUMBO_NODE_TEXT ||
child->type == GUMBO_NODE_CDATA ||
child->type == GUMBO_NODE_COMMENT)
continue;
}
push_gumbo_node(ctx, child, egn->output);
duk_put_prop_index(ctx, -2, num++);
}
}
return 1;
}
void StyleContext::initFunctions(const Scene& _scene) {
if (_scene.id == m_sceneId) {
return;
}
m_sceneId = _scene.id;
auto arr_idx = duk_push_array(m_ctx);
int id = 0;
for (auto& function : _scene.functions()) {
//logMsg("compile '%s'\n", function.c_str());
duk_push_string(m_ctx, function.c_str());
duk_push_string(m_ctx, "");
if (duk_pcompile(m_ctx, DUK_COMPILE_FUNCTION) == 0) {
duk_put_prop_index(m_ctx, arr_idx, id);
} else {
logMsg("Error: compile failed: %s\n", duk_safe_to_string(m_ctx, -1));
duk_pop(m_ctx);
}
id++;
}
if (!duk_put_global_string(m_ctx, FUNC_ID)) {
logMsg("Error: 'fns' object not set\n");
}
DUMP("setScene - %d functions\n", id);
}
bool StyleContext::setFunctions(const std::vector<std::string>& _functions) {
auto arr_idx = duk_push_array(m_ctx);
int id = 0;
bool ok = true;
for (auto& function : _functions) {
duk_push_string(m_ctx, function.c_str());
duk_push_string(m_ctx, "");
if (duk_pcompile(m_ctx, DUK_COMPILE_FUNCTION) == 0) {
duk_put_prop_index(m_ctx, arr_idx, id);
} else {
LOGW("Compile failed: %s\n%s\n---",
duk_safe_to_string(m_ctx, -1),
function.c_str());
duk_pop(m_ctx);
ok = false;
}
id++;
}
if (!duk_put_global_string(m_ctx, FUNC_ID)) {
LOGE("'fns' object not set");
}
DUMP("setFunctions\n");
return ok;
}
static int AssetDatabase_GetAssetsByImporterType(duk_context* ctx)
{
JSVM* vm = JSVM::GetJSVM(ctx);
ToolSystem* ts = vm->GetSubsystem<ToolSystem>();
AssetDatabase* db = vm->GetSubsystem<AssetDatabase>();
Project* project = ts->GetProject();
StringHash type = duk_require_string(ctx, 0);
String resourceType = duk_require_string(ctx, 1);
duk_push_array(ctx);
if (!project)
return 1;
PODVector<Asset*> assets;
db->GetAssetsByImporterType(type, resourceType, assets);
for(unsigned i = 0; i < assets.Size(); i++)
{
js_push_class_object_instance(ctx, assets[i], 0);
duk_put_prop_index(ctx, -2, i);
}
return 1;
}
static duk_ret_t test_2a(duk_context *ctx, void *udata) {
(void) udata;
/* Test first with nothing on stack index -3. */
duk_safe_call(ctx, test__null, NULL, 0, 1); printf("%s\n", duk_safe_to_string(ctx, 0));
duk_pop(ctx);
duk_set_top(ctx, 0); duk_push_undefined(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_null(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_true(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_false(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_number(ctx, 123.0); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_string(ctx, "foo\x00" "bar"); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_fixed_buffer(ctx, 16); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_pointer(ctx, NULL); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_pointer(ctx, (void *) 0xdeadbeefUL); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_object(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_array(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_c_function(ctx, dummy_func, 0); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_c_lightfunc(ctx, dummy_func, 0, 0, 0); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_eval_string(ctx, "(function dummy(){})"); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_thread(ctx); test__require_calls(ctx);
printf("done\n");
return 0;
}
static duk_ret_t dukzip_unz_listfiles(duk_context *ctx) {
unzFile archive = dukzip_unz_from_this(ctx);
unzGoToFirstFile(archive);
int i = 0, res;
duk_idx_t arr_idx = duk_push_array(ctx);
do {
// unz_file_info fileInfo;
// unzGetCurrentFileInfo(archive, &fileInfo, NULL, 0, NULL, 0, NULL, 0);
unz_file_info64 fileInfo;
unzGetCurrentFileInfo64(archive, &fileInfo, NULL, 0, NULL, 0, NULL, 0);
#if defined(__GNUC__) && !defined(DUK_NO_VLA)
char fileName[fileInfo.size_filename];
#else
char *fileName = malloc(fileInfo.size_filename);
#endif
// unzGetCurrentFileInfo(archive, &fileInfo, fileName, fileInfo.size_filename, NULL, 0, NULL, 0);
unzGetCurrentFileInfo64(archive, &fileInfo, fileName, fileInfo.size_filename, NULL, 0, NULL, 0);
duk_push_lstring(ctx, fileName, fileInfo.size_filename);
duk_put_prop_index(ctx, arr_idx, i++);
#if !defined(__GNUC__) || defined(DUK_NO_VLA)
free(fileName);
#endif
res = unzGoToNextFile(archive);
} while (res != UNZ_END_OF_LIST_OF_FILE || res == UNZ_OK);
return 1;
}
DUK_EXTERNAL void duk_push_context_dump(duk_context *ctx) {
duk_idx_t idx;
duk_idx_t top;
/* We don't duk_require_stack() here now, but rely on the caller having
* enough space.
*/
top = duk_get_top(ctx);
duk_push_array(ctx);
for (idx = 0; idx < top; idx++) {
duk_dup(ctx, idx);
duk_put_prop_index(ctx, -2, idx);
}
/* XXX: conversion errors should not propagate outwards.
* Perhaps values need to be coerced individually?
*/
duk_bi_json_stringify_helper(ctx,
duk_get_top_index(ctx), /*idx_value*/
DUK_INVALID_INDEX, /*idx_replacer*/
DUK_INVALID_INDEX, /*idx_space*/
DUK_JSON_FLAG_EXT_CUSTOM |
DUK_JSON_FLAG_ASCII_ONLY |
DUK_JSON_FLAG_AVOID_KEY_QUOTES /*flags*/);
duk_push_sprintf(ctx, "ctx: top=%ld, stack=%s", (long) top, (const char *) duk_safe_to_string(ctx, -1));
duk_replace(ctx, -3); /* [ ... arr jsonx(arr) res ] -> [ ... res jsonx(arr) ] */
duk_pop(ctx);
DUK_ASSERT(duk_is_string(ctx, -1));
}
static int FileSystem_ScanDir(duk_context* ctx)
{
duk_push_this(ctx);
FileSystem* fs = js_to_class_instance<FileSystem>(ctx, -1, 0);
if ( !duk_is_string(ctx, 0) || !duk_is_string(ctx, 1) ||
!duk_is_number(ctx, 2) || !duk_is_boolean(ctx, 3))
{
duk_push_string(ctx, "FileSystem::ScanDir bad args");
duk_throw(ctx);
}
const char* pathName = duk_to_string(ctx, 0);
const char* filter = duk_to_string(ctx, 1);
unsigned flags = duk_to_number(ctx, 2);
bool recursive = duk_to_boolean(ctx, 3) ? true : false;
Vector<String> result;
fs->ScanDir(result, pathName, filter, flags, recursive);
duk_push_array(ctx);
for (unsigned i = 0; i < result.Size(); i++)
{
duk_push_string(ctx, result[i].CString());
duk_put_prop_index(ctx, -2, i);
}
return 1;
}
static void ctx_push_ruby_object(struct state *state, VALUE obj)
{
duk_context *ctx = state->ctx;
duk_idx_t arr_idx;
VALUE str;
switch (TYPE(obj)) {
case T_FIXNUM:
duk_push_int(ctx, NUM2INT(obj));
return;
case T_FLOAT:
duk_push_number(ctx, NUM2DBL(obj));
return;
case T_SYMBOL:
#ifdef HAVE_RB_SYM2STR
obj = rb_sym2str(obj);
#else
obj = rb_id2str(SYM2ID(obj));
#endif
// Intentional fall-through:
case T_STRING:
str = encode_cesu8(state, obj);
duk_push_lstring(ctx, RSTRING_PTR(str), RSTRING_LEN(str));
return;
case T_TRUE:
duk_push_true(ctx);
return;
case T_FALSE:
duk_push_false(ctx);
return;
case T_NIL:
duk_push_null(ctx);
return;
case T_ARRAY:
arr_idx = duk_push_array(ctx);
for (int idx = 0; idx < RARRAY_LEN(obj); idx++) {
ctx_push_ruby_object(state, rb_ary_entry(obj, idx));
duk_put_prop_index(ctx, arr_idx, idx);
}
return;
case T_HASH:
duk_push_object(ctx);
rb_hash_foreach(obj, ctx_push_hash_element, (VALUE)state);
return;
default:
// Cannot convert
break;
}
clean_raise(ctx, rb_eTypeError, "cannot convert %s", rb_obj_classname(obj));
}
void test(duk_context *ctx) {
int i, n;
duk_push_c_function(ctx, func, 0);
duk_push_undefined(ctx);
duk_push_null(ctx);
duk_push_true(ctx);
duk_push_false(ctx);
duk_push_number(ctx, 123.456);
duk_push_string(ctx, "foo");
duk_push_object(ctx);
duk_push_array(ctx);
duk_push_fixed_buffer(ctx, 16);
duk_push_pointer(ctx, (void *) 0xdeadbeef);
n = duk_get_top(ctx);
printf("top: %d\n", n);
for (i = 1; i < n; i++) {
duk_dup(ctx, 0);
duk_dup(ctx, i);
duk_call_method(ctx, 0); /* [ ... func this ] -> [ ret ] */
duk_pop(ctx);
}
}
static int Material_GetShaderParameters(duk_context* ctx)
{
duk_push_this(ctx);
Material* material = js_to_class_instance<Material>(ctx, -1, 0);
const HashMap<StringHash, MaterialShaderParameter>& params = material->GetShaderParameters();
duk_push_array(ctx);
unsigned j = 0;
for (HashMap<StringHash, MaterialShaderParameter>::ConstIterator i = params.Begin(); i != params.End(); ++i)
{
duk_push_object(ctx);
duk_push_string(ctx, i->second_.name_.CString());
duk_put_prop_string(ctx, -2, "name");
js_push_variant(ctx, i->second_.value_);
duk_put_prop_string(ctx, -2, "value");
duk_push_string(ctx, i->second_.value_.ToString().CString());
duk_put_prop_string(ctx, -2, "valueString");
duk_push_string(ctx, i->second_.value_.GetTypeName().CString());
duk_put_prop_string(ctx, -2, "typeName");
duk_push_number(ctx, (double) i->second_.value_.GetType());
duk_put_prop_string(ctx, -2, "type");
duk_put_prop_index(ctx, -2, j++);
}
return 1;
}
static duk_ret_t
js_Font_wordWrapString(duk_context* ctx)
{
const char* text = duk_to_string(ctx, 0);
int width = duk_require_int(ctx, 1);
font_t* font;
int num_lines;
wraptext_t* wraptext;
int i;
duk_push_this(ctx);
font = duk_require_sphere_obj(ctx, -1, "Font");
duk_pop(ctx);
wraptext = word_wrap_text(font, text, width);
num_lines = get_wraptext_line_count(wraptext);
duk_push_array(ctx);
for (i = 0; i < num_lines; ++i) {
duk_push_string(ctx, get_wraptext_line(wraptext, i));
duk_put_prop_index(ctx, -2, i);
}
free_wraptext(wraptext);
return 1;
}
void OnSignal(Entity * param0, Entity * param1, const float3 & param2, const float3 & param3, float param4, float param5, bool param6)
{
duk_context* ctx = ctx_;
duk_push_global_object(ctx);
duk_get_prop_string(ctx, -1, "_OnSignal");
duk_remove(ctx, -2);
duk_push_number(ctx, (size_t)key_);
duk_push_array(ctx);
PushWeakObject(ctx, param0);
duk_put_prop_index(ctx, -2, 0);
PushWeakObject(ctx, param1);
duk_put_prop_index(ctx, -2, 1);
PushValueObjectCopy<float3>(ctx, param2, float3_ID, float3_Finalizer);
duk_put_prop_index(ctx, -2, 2);
PushValueObjectCopy<float3>(ctx, param3, float3_ID, float3_Finalizer);
duk_put_prop_index(ctx, -2, 3);
duk_push_number(ctx, param4);
duk_put_prop_index(ctx, -2, 4);
duk_push_number(ctx, param5);
duk_put_prop_index(ctx, -2, 5);
duk_push_boolean(ctx, param6);
duk_put_prop_index(ctx, -2, 6);
bool success = duk_pcall(ctx, 2) == 0;
if (!success) LogError("[JavaScript] OnSignal: " + GetErrorString(ctx));
duk_pop(ctx);
}
AJ_Status AJS_RegisterIO(duk_context* ctx, duk_idx_t ioIdx)
{
duk_idx_t pinIdx;
duk_idx_t i;
uint16_t numPins = AJS_TargetIO_GetNumPins();
/*
* Create base pin protoype
*/
pinIdx = duk_push_object(ctx);
AJS_SetPropertyAccessors(ctx, pinIdx, "functions", NULL, NativeFunctionsGetter);
AJS_SetPropertyAccessors(ctx, pinIdx, "info", NULL, NativeInfoGetter);
/*
* Create the pin objects
*/
duk_push_array(ctx);
for (i = 0; i < numPins; ++i) {
AJS_CreateObjectFromPrototype(ctx, pinIdx);
duk_push_int(ctx, i);
duk_put_prop_string(ctx, -2, "id");
duk_put_prop_index(ctx, -2, i);
}
duk_put_prop_string(ctx, ioIdx, "pin");
duk_pop(ctx);
/*
* Register the native functions
*/
AJS_PutFunctionList(ctx, ioIdx, io_native_functions, TRUE);
/*
* GPIO attribute constants
*/
duk_put_number_list(ctx, ioIdx, io_constants);
/*
* A hidden property for keeping track of triggers
*/
duk_push_string(ctx, AJS_HIDDEN_PROP("trigs"));
duk_push_array(ctx);
duk_def_prop(ctx, ioIdx, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_HAVE_WRITABLE);
/*
* Compact the IO object and set it on the global object
*/
duk_compact(ctx, ioIdx);
duk_dup(ctx, ioIdx);
duk_put_global_string(ctx, AJS_IOObjectName);
return AJ_OK;
}
DUK_INTERNAL duk_ret_t duk_bi_array_prototype_slice(duk_context *ctx) {
duk_uint32_t len;
duk_int_t start, end;
duk_int_t i;
duk_uarridx_t idx;
duk_uint32_t res_length = 0;
/* XXX: len >= 0x80000000 won't work below because we need to be
* able to represent -len.
*/
len = duk__push_this_obj_len_u32_limited(ctx);
duk_push_array(ctx);
/* stack[0] = start
* stack[1] = end
* stack[2] = ToObject(this)
* stack[3] = ToUint32(length)
* stack[4] = result array
*/
start = duk_to_int_clamped(ctx, 0, -((duk_int_t) len), (duk_int_t) len);
if (start < 0) {
start = len + start;
}
/* XXX: could duk_is_undefined() provide defaulting undefined to 'len'
* (the upper limit)?
*/
if (duk_is_undefined(ctx, 1)) {
end = len;
} else {
end = duk_to_int_clamped(ctx, 1, -((duk_int_t) len), (duk_int_t) len);
if (end < 0) {
end = len + end;
}
}
DUK_ASSERT(start >= 0 && (duk_uint32_t) start <= len);
DUK_ASSERT(end >= 0 && (duk_uint32_t) end <= len);
idx = 0;
for (i = start; i < end; i++) {
DUK_ASSERT_TOP(ctx, 5);
if (duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) {
duk_xdef_prop_index_wec(ctx, 4, idx);
res_length = idx + 1;
} else {
duk_pop(ctx);
}
idx++;
DUK_ASSERT_TOP(ctx, 5);
}
duk_push_u32(ctx, res_length);
duk_xdef_prop_stridx(ctx, 4, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
DUK_ASSERT_TOP(ctx, 5);
return 1;
}
void StyleContext::parseSceneGlobals(const YAML::Node& node, const std::string& key, int seqIndex,
duk_idx_t dukObject) {
switch(node.Type()) {
case YAML::NodeType::Scalar:
if (key.size() == 0) {
duk_push_string(m_ctx, node.Scalar().c_str());
duk_put_prop_index(m_ctx, dukObject, seqIndex);
} else {
auto nodeValue = node.Scalar();
if (nodeValue.compare(0, 8, "function") == 0) {
duk_push_string(m_ctx, key.c_str()); // push property key
duk_push_string(m_ctx, nodeValue.c_str()); // push function string
duk_push_string(m_ctx, "");
if (duk_pcompile(m_ctx, DUK_COMPILE_FUNCTION) == 0) { // compile function
duk_put_prop(m_ctx, -3); // put {key: function()}
} else {
LOGW("Compile failed in global function: %s\n%s\n---",
duk_safe_to_string(m_ctx, -1),
nodeValue.c_str());
duk_pop(m_ctx); //pop error
duk_pop(m_ctx); //pop key
// push property as a string
duk_push_string(m_ctx, nodeValue.c_str());
duk_put_prop_string(m_ctx, dukObject, key.c_str());
}
} else {
duk_push_string(m_ctx, nodeValue.c_str());
duk_put_prop_string(m_ctx, dukObject, key.c_str());
}
}
break;
case YAML::NodeType::Sequence:
{
auto seqObj = duk_push_array(m_ctx);
for (int i = 0; i < node.size(); i++) {
parseSceneGlobals(node[i], "", i, seqObj);
}
duk_put_prop_string(m_ctx, seqObj-1, key.c_str());
break;
}
case YAML::NodeType::Map:
{
//duk_push_string(m_ctx, key.c_str());
auto mapObj = duk_push_object(m_ctx);
for (auto& mapNode : node) {
auto itemKey = mapNode.first.Scalar();
parseSceneGlobals(mapNode.second, itemKey, 0, mapObj);
}
duk_put_prop_string(m_ctx, mapObj-1, key.c_str());
}
default:
break;
}
return;
}
void PushStringVector(duk_context* ctx, const Vector<String>& vector)
{
duk_push_array(ctx);
for (unsigned i = 0; i < vector.Size(); ++i)
{
duk_push_string(ctx, vector[i].CString());
duk_put_prop_index(ctx, -2, i);
}
}
void test(duk_context *ctx) {
duk_idx_t i, n;
duk_push_undefined(ctx);
duk_push_null(ctx);
duk_push_boolean(ctx, 0);
duk_push_boolean(ctx, 123);
duk_push_number(ctx, 234);
duk_push_string(ctx, "foo");
duk_push_object(ctx);
duk_push_array(ctx);
duk_push_c_function(ctx, my_c_func, DUK_VARARGS);
duk_push_fixed_buffer(ctx, 1024);
duk_push_dynamic_buffer(ctx, 1024);
duk_push_pointer(ctx, (void *) 0xdeadbeefUL);
n = duk_get_top(ctx);
for (i = 0; i < n + 1; i++) { /* end on invalid index on purpose */
duk_int_t typeval, typemask;
typeval = duk_get_type(ctx, i);
typemask = duk_get_type_mask(ctx, i);
printf("stack[%ld] --> type=%ld mask=0x%08lx ",
(long) i, (long) typeval, (long) typemask);
switch(duk_get_type(ctx, i)) {
case DUK_TYPE_NONE: printf("none"); break;
case DUK_TYPE_UNDEFINED: printf("undefined"); break;
case DUK_TYPE_NULL: printf("null"); break;
case DUK_TYPE_BOOLEAN: printf("boolean"); break;
case DUK_TYPE_NUMBER: printf("number"); break;
case DUK_TYPE_STRING: printf("string"); break;
case DUK_TYPE_OBJECT: printf("object"); break;
case DUK_TYPE_BUFFER: printf("buffer"); break;
case DUK_TYPE_POINTER: printf("pointer"); break;
default: printf("unknown(%d)", (int) duk_get_type(ctx, i)); break;
}
printf(" bool=%d num=%lf str=%s buf-is-null=%d ptr=%p",
(int) duk_get_boolean(ctx, i),
(double) duk_get_number(ctx, i),
duk_get_string(ctx, i),
(duk_get_buffer(ctx, i, NULL) == NULL ? 1 : 0),
duk_get_pointer(ctx, i));
printf(" isobj=%d isarr=%d isfunc=%d",
(int) duk_is_object(ctx, i),
(int) duk_is_array(ctx, i),
(int) duk_is_function(ctx, i));
printf("\n");
}
}
int duk_bi_array_prototype_slice(duk_context *ctx) {
unsigned int len;
int start, end;
int idx;
int i;
duk_uint32_t res_length = 0;
len = duk__push_this_obj_len_u32(ctx);
duk_push_array(ctx);
/* stack[0] = start
* stack[1] = end
* stack[2] = ToObject(this)
* stack[3] = ToUint32(length)
* stack[4] = result array
*/
start = duk_to_int_clamped(ctx, 0, -len, len); /* FIXME: does not support full 32-bit range */
if (start < 0) {
start = len + start;
}
/* FIXME: could duk_is_undefined() provide defaulting undefined to 'len'
* (the upper limit)?
*/
if (duk_is_undefined(ctx, 1)) {
end = len;
} else {
end = duk_to_int_clamped(ctx, 1, -len, len);
if (end < 0) {
end = len + end;
}
}
DUK_ASSERT(start >= 0 && (duk_uint32_t) start <= len);
DUK_ASSERT(end >= 0 && (duk_uint32_t) end <= len);
idx = 0;
for (i = start; i < end; i++) {
DUK_ASSERT_TOP(ctx, 5);
if (duk_get_prop_index(ctx, 2, i)) {
duk_def_prop_index(ctx, 4, idx, DUK_PROPDESC_FLAGS_WEC);
res_length = idx + 1;
} else {
duk_pop(ctx);
}
idx++;
DUK_ASSERT_TOP(ctx, 5);
}
duk_push_int(ctx, res_length); /* FIXME */
duk_def_prop_stridx(ctx, 4, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
DUK_ASSERT_TOP(ctx, 5);
return 1;
}
static int ncurses_getmaxyx(duk_context *ctx) {
int row, col;
getmaxyx(stdscr, row, col);
duk_push_array(ctx);
duk_push_int(ctx, row);
duk_put_prop_index(ctx, -2, 0);
duk_push_int(ctx, col);
duk_put_prop_index(ctx, -2, 1);
return 1;
}
static int
es_gumbo_find_by_class(duk_context *ctx)
{
es_gumbo_node_t *egn = es_get_native_obj(ctx, 0, &es_native_gumbo_node);
const char *cls = duk_to_string(ctx, 1);
int idx = 0;
duk_push_array(ctx);
char **classlist = strvec_split(cls, ' ');
es_gumbo_find_by_class_r(egn->node, classlist, ctx, &idx, egn->output);
strvec_free(classlist);
return 1;
}
void OnSignal()
{
duk_context* ctx = ctx_;
duk_push_global_object(ctx);
duk_get_prop_string(ctx, -1, "_OnSignal");
duk_remove(ctx, -2);
duk_push_number(ctx, (size_t)key_);
duk_push_array(ctx);
bool success = duk_pcall(ctx, 2) == 0;
if (!success) LogError("[JavaScript] OnSignal: " + GetErrorString(ctx));
duk_pop(ctx);
}
/*
* Create a global array refs in the heap stash.
*/
void
mn_ref_setup(duk_context *ctx) {
duk_push_heap_stash(ctx);
/* Create a new array with one `0` at index `0`. */
duk_push_array(ctx);
duk_push_int(ctx, 0);
duk_put_prop_index(ctx, -2, 0);
/* Store it as "refs" in the heap stash */
duk_put_prop_string(ctx, -2, "refs");
duk_pop(ctx);
}
static int
es_gumbo_find_by_tag_name(duk_context *ctx)
{
es_gumbo_node_t *egn = es_get_native_obj(ctx, 0, &es_native_gumbo_node);
const char *tagstr = duk_to_string(ctx, 1);
GumboTag tag = gumbo_tag_enum(tagstr);
if(tag == GUMBO_TAG_UNKNOWN)
duk_error(ctx, DUK_ERR_ERROR, "Unknown tag %s", tagstr);
int idx = 0;
duk_push_array(ctx);
es_gumbo_find_by_tag_name_r(egn->node, tag, ctx, &idx, egn->output);
return 1;
}
static void duknode_push_argv(duk_context *ctx, int argc, const char *argv[]) {
duk_get_global_string(ctx, "process");
duk_idx_t arg_array_index; int i;
arg_array_index = duk_push_array(ctx);
for (i = 0; i < argc; i++) {
duk_push_string(ctx, argv[i]);
duk_put_prop_index(ctx, arg_array_index, i);
}
duk_put_prop_string(ctx, -2, "argv");
duk_pop(ctx);
}
static duk_ret_t test_json_serialize_1(duk_context *ctx, void *udata) {
unsigned char *data;
int i;
duk_uarridx_t arridx = 0;
(void) udata;
data = (unsigned char *) duk_push_dynamic_buffer(ctx, 20);
for (i = 0; i < 20; i++) {
data[i] = 0x40 + i;
}
duk_push_array(ctx); /* index 1 */
setup_duktape_buffer(ctx, 0);
duk_put_prop_index(ctx, 1, arridx++);
setup_nodejs_buffer(ctx, 0);
duk_put_prop_index(ctx, 1, arridx++);
setup_nodejs_buffer_slice(ctx, 0, 3, 5);
duk_put_prop_index(ctx, 1, arridx++);
setup_arraybuffer(ctx, 0);
duk_put_prop_index(ctx, 1, arridx++);
setup_typedarray(ctx, 0, "Uint8Array");
duk_put_prop_index(ctx, 1, arridx++);
setup_typedarray_slice(ctx, 0, "Uint8Array", 2, 6);
duk_put_prop_index(ctx, 1, arridx++);
setup_typedarray(ctx, 0, "Uint32Array");
duk_put_prop_index(ctx, 1, arridx++);
setup_typedarray_slice(ctx, 0, "Uint32Array", 4, 1);
duk_put_prop_index(ctx, 1, arridx++);
/* Serialize with a full backing buffer first. */
for (i = 20; i >= 0; i--) {
printf("resize to %d\n", i);
duk_resize_buffer(ctx, 0, i);
duk_dup(ctx, 1);
duk_json_encode(ctx, -1);
printf("%s\n", duk_to_string(ctx, -1));
duk_pop(ctx);
duk_eval_string(ctx, "(function (v) { print(Duktape.enc('jx', v)); })");
duk_dup(ctx, 1);
duk_call(ctx, 1);
duk_pop(ctx);
}
printf("final top: %ld\n", (long) duk_get_top(ctx));
return 0;
}
void OnSignal(IAssetTransfer * param0, String param1)
{
duk_context* ctx = ctx_;
duk_push_global_object(ctx);
duk_get_prop_string(ctx, -1, "_OnSignal");
duk_remove(ctx, -2);
duk_push_number(ctx, (size_t)key_);
duk_push_array(ctx);
PushWeakObject(ctx, param0);
duk_put_prop_index(ctx, -2, 0);
duk_push_string(ctx, param1.CString());
duk_put_prop_index(ctx, -2, 1);
bool success = duk_pcall(ctx, 2) == 0;
if (!success) LogError("[JavaScript] OnSignal: " + GetErrorString(ctx));
duk_pop(ctx);
}
void Emerobot::InstallAPI()
{
InstallAPI_pctl();
InstallAPI_bitcoin();
duk_idx_t arr_idx = duk_push_array (ctx);
for ( int i=0; i<Argc; i++ )
{
duk_push_string ( ctx, Argv[i]->c_str() );
duk_put_prop_index ( ctx, arr_idx, i );
}
duk_put_prop_string ( ctx, -2, "ARGV" );
}
static int ModelImporter_GetAnimations(duk_context* ctx)
{
duk_push_this(ctx);
ModelImporter* importer = js_to_class_instance<ModelImporter>(ctx, -1, 0);
PODVector<Animation*> animations;
importer->GetAnimations(animations);
duk_push_array(ctx);
for(unsigned i = 0; i < animations.Size(); i++)
{
js_push_class_object_instance(ctx, animations[i], 0);
duk_put_prop_index(ctx, -2, i);
}
return 1;
}