/*
* 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 void remapCallback(void* data, s32 x, s32 y, RemapResult* result)
{
RemapData* remap = (RemapData*)data;
duk_context* duk = remap->duk;
duk_push_heapptr(duk, remap->remap);
duk_push_int(duk, result->index);
duk_push_int(duk, x);
duk_push_int(duk, y);
duk_pcall(duk, 3);
if(duk_is_array(duk, -1))
{
duk_get_prop_index(duk, -1, 0);
result->index = duk_to_int(duk, -1);
duk_pop(duk);
duk_get_prop_index(duk, -1, 1);
result->flip = duk_to_int(duk, -1);
duk_pop(duk);
duk_get_prop_index(duk, -1, 2);
result->rotate = duk_to_int(duk, -1);
duk_pop(duk);
}
else
{
result->index = duk_to_int(duk, -1);
}
duk_pop(duk);
}
void test(duk_context *ctx) {
duk_idx_t arr_idx;
duk_push_int(ctx, 123); /* dummy */
arr_idx = duk_push_bare_array(ctx);
printf("arr_idx = %ld\n", (long) arr_idx);
duk_get_prototype(ctx, -1);
printf("prototype is undefined: %ld\n", (long) duk_is_undefined(ctx, -1));
duk_pop(ctx);
duk_push_string(ctx, "foo");
duk_put_prop_index(ctx, arr_idx, 0);
duk_push_string(ctx, "bar");
duk_put_prop_index(ctx, arr_idx, 1);
/* Array is now: [ "foo", "bar" ], and array.length is 2 (automatically
* updated for ECMAScript arrays). The array being bare does not affect
* JSON serialization.
*/
printf("duk_is_array(%ld) = %d\n", (long) arr_idx, (int) duk_is_array(ctx, arr_idx));
duk_eval_string_noresult(ctx, "Array.prototype[5] = 'inherit';");
(void) duk_get_prop_index(ctx, arr_idx, 5);
printf("arr[5] = '%s'\n", duk_to_string(ctx, -1));
duk_pop(ctx);
duk_json_encode(ctx, arr_idx); /* in-place */
printf("json encoded: %s\n", duk_get_string(ctx, arr_idx));
printf("top=%ld\n", (long) duk_get_top(ctx));
}
int* getIntArray(duk_context *ctx, int stackIndex) {
static int* result = NULL;
if(duk_is_array(ctx, stackIndex)) {
int resultLen = duk_get_length(ctx, stackIndex);
result = (int*)malloc( resultLen * sizeof(int) );
memset(result,0,resultLen);
duk_enum(ctx, stackIndex, DUK_ENUM_ARRAY_INDICES_ONLY);
// NOT stackIndex because waits enumIndex that is -1
int idx=0;
while (duk_next(ctx, -1, 1)) {
// in JS/duktape toto[1] <=> toto["1"]
// that's why keys are strings
const char* k = duk_to_string(ctx, -2);
int v = duk_to_int(ctx, -1);
//printf("key=%s, value=%d\n", k, v);
result[idx++] = v;
duk_pop_2(ctx);
}
duk_pop(ctx); // duk_enum
} else {
printf("Found NO array\n");
}
return result;
}
static duk_ret_t
js_PointSeries(duk_context* ctx)
{
duk_require_object_coercible(ctx, 0);
color_t color = duk_require_sphere_color(ctx, 1);
size_t num_points;
int x, y;
ALLEGRO_VERTEX* vertices;
ALLEGRO_COLOR vtx_color;
size_t i;
if (!duk_is_array(ctx, 0))
duk_error_ni(ctx, -1, DUK_ERR_ERROR, "PointSeries(): First argument must be an array");
duk_get_prop_string(ctx, 0, "length"); num_points = duk_get_uint(ctx, 0); duk_pop(ctx);
if (num_points < 1)
duk_error_ni(ctx, -1, DUK_ERR_RANGE_ERROR, "PointSeries(): One or more vertices required");
if (num_points > INT_MAX)
duk_error_ni(ctx, -1, DUK_ERR_RANGE_ERROR, "PointSeries(): Too many vertices");
if ((vertices = calloc(num_points, sizeof(ALLEGRO_VERTEX))) == NULL)
duk_error_ni(ctx, -1, DUK_ERR_ERROR, "PointSeries(): Failed to allocate vertex buffer");
vtx_color = nativecolor(color);
for (i = 0; i < num_points; ++i) {
duk_get_prop_index(ctx, 0, (duk_uarridx_t)i);
duk_get_prop_string(ctx, 0, "x"); x = duk_require_int(ctx, -1); duk_pop(ctx);
duk_get_prop_string(ctx, 0, "y"); y = duk_require_int(ctx, -1); duk_pop(ctx);
duk_pop(ctx);
vertices[i].x = x + 0.5; vertices[i].y = y + 0.5;
vertices[i].color = vtx_color;
}
al_draw_prim(vertices, NULL, NULL, 0, (int)num_points, ALLEGRO_PRIM_POINT_LIST);
free(vertices);
return 0;
}
static int UIButton_Popup(duk_context* ctx)
{
if (!duk_is_object(ctx, 0))
{
duk_push_string(ctx, "UIButton.popup first argument must be an object");
duk_throw(ctx);
}
if (!duk_is_callable(ctx, 1))
{
duk_push_string(ctx, "UIButton.popup second argument must be callable");
duk_throw(ctx);
}
JSVM* vm = JSVM::GetJSVM(ctx);
duk_enum(ctx, 0, DUK_ENUM_OWN_PROPERTIES_ONLY);
UISelectItemSource* source = new UISelectItemSource(vm->GetContext());
while (duk_next(ctx, -1, 0)) {
String key = duk_get_string(ctx, -1);
duk_get_prop(ctx, 0);
if (duk_is_array(ctx, -1))
{
// need to support this, for skin image, etc
assert(0);
}
else if (duk_is_string(ctx, -1))
{
// id
String id = duk_get_string(ctx, -1);
source->AddItem(new UISelectItem(vm->GetContext(), key, id));
}
else
{
duk_push_string(ctx, "UIButton.popup data object key is not an array or string");
duk_throw(ctx);
}
duk_pop(ctx); // pop key value
}
duk_pop(ctx); // pop enum object
duk_push_this(ctx);
duk_dup(ctx, 1);
duk_put_prop_string(ctx, -2, "__popup_menu_callback");
UIButton* button = js_to_class_instance<UIButton>(ctx, -1, 0);
UIMenuWindow* menuWindow = new UIMenuWindow(vm->GetContext(), button, "__popup-menu");
menuWindow->Show(source);
duk_pop(ctx);
return 0;
}
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");
}
}
gboolean
_gum_duk_parse_bytes (duk_context * ctx,
duk_idx_t index,
GBytes ** bytes)
{
gpointer data;
duk_size_t size;
data = duk_get_buffer_data (ctx, index, &size);
if (data != NULL)
{
*bytes = g_bytes_new (data, size);
return TRUE;
}
else if (duk_is_array (ctx, index))
{
duk_size_t i;
duk_get_prop_string (ctx, index, "length");
size = duk_get_uint (ctx, -1);
duk_pop (ctx);
if (size >= GUM_MAX_JS_BYTE_ARRAY_LENGTH)
return FALSE;
data = g_malloc (size);
for (i = 0; i != size; i++)
{
duk_get_prop_index (ctx, index, (duk_uarridx_t) i);
((guint8 *) data)[i] = duk_get_uint (ctx, -1) & 0xff;
duk_pop (ctx);
}
*bytes = g_bytes_new_take (data, size);
return TRUE;
}
else if (duk_is_null_or_undefined (ctx, index) ||
duk_is_boolean (ctx, index) ||
duk_is_number (ctx, index) ||
duk_is_nan (ctx, index) ||
duk_is_string (ctx, index) ||
duk_is_function (ctx, index))
{
return FALSE;
}
*bytes = g_bytes_new (NULL, 0);
return TRUE;
}
/*
* Serializes various data types into a buffer. Leaves the buffer on the top of the stack.
*/
static uint8_t* SerializeToBuffer(duk_context* ctx, duk_idx_t idx, duk_size_t* sz)
{
uint8_t* ptr;
switch (duk_get_type(ctx, idx)) {
case DUK_TYPE_BUFFER:
duk_dup(ctx, idx);
ptr = duk_get_buffer(ctx, -1, sz);
break;
case DUK_TYPE_BOOLEAN:
ptr = duk_push_fixed_buffer(ctx, 1);
ptr[0] = duk_get_boolean(ctx, idx);
*sz = 1;
break;
case DUK_TYPE_NUMBER:
ptr = duk_push_fixed_buffer(ctx, 1);
ptr[0] = duk_get_int(ctx, idx);
*sz = 1;
break;
case DUK_TYPE_STRING:
duk_dup(ctx, idx);
ptr = duk_to_fixed_buffer(ctx, -1, sz);
break;
case DUK_TYPE_OBJECT:
if (duk_is_array(ctx, idx)) {
duk_idx_t i;
duk_idx_t len = duk_get_length(ctx, idx);
ptr = duk_push_fixed_buffer(ctx, len);
for (i = 0; i < len; ++i) {
duk_get_prop_index(ctx, idx, i);
ptr[i] = duk_require_uint(ctx, -1);
duk_pop(ctx);
}
*sz = len;
} else {
duk_error(ctx, DUK_ERR_TYPE_ERROR, "Can only serialize arrays of numbers");
}
break;
default:
duk_error(ctx, DUK_ERR_TYPE_ERROR, "Cannot serialize");
break;
}
return ptr;
}
static duk_ret_t duk_spr(duk_context* duk)
{
static u8 colors[TIC_PALETTE_SIZE];
s32 count = 0;
s32 index = duk_is_null_or_undefined(duk, 0) ? 0 : duk_to_int(duk, 0);
s32 x = duk_is_null_or_undefined(duk, 1) ? 0 : duk_to_int(duk, 1);
s32 y = duk_is_null_or_undefined(duk, 2) ? 0 : duk_to_int(duk, 2);
{
if(!duk_is_null_or_undefined(duk, 3))
{
if(duk_is_array(duk, 3))
{
for(s32 i = 0; i < TIC_PALETTE_SIZE; i++)
{
duk_get_prop_index(duk, 3, i);
if(duk_is_null_or_undefined(duk, -1))
{
duk_pop(duk);
break;
}
else
{
colors[i] = duk_to_int(duk, -1);
count++;
duk_pop(duk);
}
}
}
else
{
colors[0] = duk_to_int(duk, 3);
count = 1;
}
}
}
s32 scale = duk_is_null_or_undefined(duk, 4) ? 1 : duk_to_int(duk, 4);
tic_flip flip = duk_is_null_or_undefined(duk, 5) ? tic_no_flip : duk_to_int(duk, 5);
tic_rotate rotate = duk_is_null_or_undefined(duk, 6) ? tic_no_rotate : duk_to_int(duk, 6);
s32 w = duk_is_null_or_undefined(duk, 7) ? 1 : duk_to_int(duk, 7);
s32 h = duk_is_null_or_undefined(duk, 8) ? 1 : duk_to_int(duk, 8);
tic_mem* memory = (tic_mem*)getDukMachine(duk);
memory->api.sprite_ex(memory, &memory->ram.tiles, index, x, y, w, h, colors, count, scale, flip, rotate);
return 0;
}
jobject DuktapeContext::evaluate(JNIEnv* env, jstring code, jstring fname) const {
CHECK_STACK(m_context);
const JString sourceCode(env, code);
const JString fileName(env, fname);
if (eval_string_with_filename(m_context, sourceCode, fileName) != DUK_EXEC_SUCCESS) {
queueJavaExceptionForDuktapeError(env, m_context);
return nullptr;
}
const int supportedTypeMask = DUK_TYPE_MASK_BOOLEAN | DUK_TYPE_MASK_NUMBER | DUK_TYPE_MASK_STRING;
if (duk_check_type_mask(m_context, -1, supportedTypeMask)) {
// The result is a supported scalar type - return it.
return m_objectType->pop(m_context, env, false).l;
} else if (duk_is_array(m_context, -1)) {
return m_objectType->popArray(m_context, env, 1, false, false);
} else {
// The result is an unsupported type, undefined, or null.
duk_pop(m_context);
return nullptr;
}
}
CEJsValue js_to_cejs_value(duk_context* ctx, int index)
{
if (duk_is_number(ctx, index))
return JS_NUMBER(duk_to_number(ctx, index));
if (duk_is_boolean(ctx, index))
return JS_BOOL(duk_to_boolean(ctx, index));
if (duk_is_string(ctx, index))
return JS_STRING(duk_to_string(ctx, index));
if (duk_is_array(ctx, index))
return JS_STRING(duk_json_encode(ctx, index));
if (duk_is_object(ctx, index))
return JS_STRING(duk_json_encode(ctx, index));
if (duk_is_undefined(ctx, index)) {
return JS_UNDEFINED;
}
return JS_NULL;
}
//duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index);
duk_bool_t aperl_duk_is_array(duk_context *ctx, duk_idx_t index) {
duk_bool_t ret = duk_is_array(ctx, index);
return ret;
}
static duk_ret_t test_func(duk_context *ctx, void *udata) {
(void) udata;
if (ctx) {
printf("dummy - return here\n"); fflush(stdout);
return 0;
}
/* Up-to-date for Duktape 1.3.0, alphabetical order:
* $ cd website/api; ls *.yaml
*/
(void) duk_alloc_raw(ctx, 0);
(void) duk_alloc(ctx, 0);
(void) duk_base64_decode(ctx, 0);
(void) duk_base64_encode(ctx, 0);
(void) duk_buffer_to_string(ctx, 0);
(void) duk_call_method(ctx, 0);
(void) duk_call_prop(ctx, 0, 0);
(void) duk_call(ctx, 0);
(void) duk_char_code_at(ctx, 0, 0);
(void) duk_check_stack_top(ctx, 0);
(void) duk_check_stack(ctx, 0);
(void) duk_check_type_mask(ctx, 0, 0);
(void) duk_check_type(ctx, 0, 0);
(void) duk_compact(ctx, 0);
(void) duk_compile_lstring_filename(ctx, 0, "dummy", 0);
(void) duk_compile_lstring(ctx, 0, "dummy", 0);
(void) duk_compile_string_filename(ctx, 0, "dummy");
(void) duk_compile_string(ctx, 0, "dummy");
(void) duk_compile(ctx, 0);
(void) duk_concat(ctx, 0);
(void) duk_config_buffer(ctx, 0, NULL, 0);
(void) duk_copy(ctx, 0, 0);
(void) duk_create_heap_default();
(void) duk_create_heap(NULL, NULL, NULL, NULL, NULL);
(void) duk_debugger_attach(ctx, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
(void) duk_debugger_cooperate(ctx);
(void) duk_debugger_detach(ctx);
(void) duk_debugger_notify(ctx, 0);
(void) duk_debugger_pause(ctx);
(void) duk_decode_string(ctx, 0, NULL, NULL);
(void) duk_def_prop(ctx, 0, 0);
(void) duk_del_prop_index(ctx, 0, 0);
(void) duk_del_prop_string(ctx, 0, "dummy");
(void) duk_del_prop(ctx, 0);
(void) duk_destroy_heap(ctx);
(void) duk_dump_function(ctx);
(void) duk_dup_top(ctx);
(void) duk_dup(ctx, 0);
(void) duk_enum(ctx, 0, 0);
(void) duk_equals(ctx, 0, 0);
duk_error_va(ctx, 0, NULL, NULL);
duk_error(ctx, 0, "dummy"); /* (void) cast won't work without variadic macros */
(void) duk_eval_lstring_noresult(ctx, "dummy", 0);
(void) duk_eval_lstring(ctx, "dummy", 0);
(void) duk_eval_noresult(ctx);
(void) duk_eval_string_noresult(ctx, "dummy");
(void) duk_eval_string(ctx, "dummy");
(void) duk_eval(ctx);
(void) duk_fatal(ctx, "dummy");
(void) duk_free_raw(ctx, NULL);
(void) duk_free(ctx, NULL);
(void) duk_gc(ctx, 0);
(void) duk_get_boolean(ctx, 0);
(void) duk_get_buffer_data(ctx, 0, NULL);
(void) duk_get_buffer(ctx, 0, NULL);
(void) duk_get_c_function(ctx, 0);
(void) duk_get_context(ctx, 0);
(void) duk_get_current_magic(ctx);
(void) duk_get_error_code(ctx, 0);
(void) duk_get_finalizer(ctx, 0);
(void) duk_get_global_string(ctx, 0);
(void) duk_get_heapptr(ctx, 0);
(void) duk_get_int(ctx, 0);
(void) duk_get_length(ctx, 0);
(void) duk_get_lstring(ctx, 0, NULL);
(void) duk_get_magic(ctx, 0);
(void) duk_get_memory_functions(ctx, NULL);
(void) duk_get_number(ctx, 0);
(void) duk_get_pointer(ctx, 0);
(void) duk_get_prop_index(ctx, 0, 0);
(void) duk_get_prop_string(ctx, 0, "dummy");
(void) duk_get_prop(ctx, 0);
(void) duk_get_prototype(ctx, 0);
(void) duk_get_string(ctx, 0);
(void) duk_get_top_index(ctx);
(void) duk_get_top(ctx);
(void) duk_get_type_mask(ctx, 0);
(void) duk_get_type(ctx, 0);
(void) duk_get_uint(ctx, 0);
(void) duk_has_prop_index(ctx, 0, 0);
(void) duk_has_prop_string(ctx, 0, "dummy");
(void) duk_has_prop(ctx, 0);
(void) duk_hex_decode(ctx, 0);
(void) duk_hex_encode(ctx, 0);
(void) duk_insert(ctx, 0);
(void) duk_instanceof(ctx, 0, 0);
(void) duk_is_array(ctx, 0);
(void) duk_is_boolean(ctx, 0);
(void) duk_is_bound_function(ctx, 0);
(void) duk_is_buffer(ctx, 0);
(void) duk_is_callable(ctx, 0);
(void) duk_is_c_function(ctx, 0);
(void) duk_is_constructor_call(ctx);
(void) duk_is_dynamic_buffer(ctx, 0);
(void) duk_is_ecmascript_function(ctx, 0);
(void) duk_is_error(ctx, 0);
(void) duk_is_eval_error(ctx, 0);
(void) duk_is_fixed_buffer(ctx, 0);
(void) duk_is_function(ctx, 0);
(void) duk_is_lightfunc(ctx, 0);
(void) duk_is_nan(ctx, 0);
(void) duk_is_null_or_undefined(ctx, 0);
(void) duk_is_null(ctx, 0);
(void) duk_is_number(ctx, 0);
(void) duk_is_object_coercible(ctx, 0);
(void) duk_is_object(ctx, 0);
(void) duk_is_pointer(ctx, 0);
(void) duk_is_primitive(ctx, 0);
(void) duk_is_range_error(ctx, 0);
(void) duk_is_reference_error(ctx, 0);
(void) duk_is_strict_call(ctx);
(void) duk_is_string(ctx, 0);
(void) duk_is_syntax_error(ctx, 0);
(void) duk_is_thread(ctx, 0);
(void) duk_is_type_error(ctx, 0);
(void) duk_is_undefined(ctx, 0);
(void) duk_is_uri_error(ctx, 0);
(void) duk_is_valid_index(ctx, 0);
(void) duk_join(ctx, 0);
(void) duk_json_decode(ctx, 0);
(void) duk_json_encode(ctx, 0);
(void) duk_load_function(ctx);
(void) duk_map_string(ctx, 0, NULL, NULL);
(void) duk_new(ctx, 0);
(void) duk_next(ctx, 0, 0);
(void) duk_normalize_index(ctx, 0);
(void) duk_pcall_method(ctx, 0);
(void) duk_pcall_prop(ctx, 0, 0);
(void) duk_pcall(ctx, 0);
(void) duk_pcompile_lstring_filename(ctx, 0, "dummy", 0);
(void) duk_pcompile_lstring(ctx, 0, "dummy", 0);
(void) duk_pcompile_string_filename(ctx, 0, "dummy");
(void) duk_pcompile_string(ctx, 0, "dummy");
(void) duk_pcompile(ctx, 0);
(void) duk_peval_lstring_noresult(ctx, "dummy", 0);
(void) duk_peval_lstring(ctx, "dummy", 0);
(void) duk_peval_noresult(ctx);
(void) duk_peval_string_noresult(ctx, "dummy");
(void) duk_peval_string(ctx, "dummy");
(void) duk_peval(ctx);
(void) duk_pnew(ctx, 0);
(void) duk_pop_2(ctx);
(void) duk_pop_3(ctx);
(void) duk_pop_n(ctx, 0);
(void) duk_pop(ctx);
(void) duk_push_array(ctx);
(void) duk_push_boolean(ctx, 0);
(void) duk_push_buffer_object(ctx, 0, 0, 0, 0);
(void) duk_push_buffer(ctx, 0, 0);
(void) duk_push_c_function(ctx, NULL, 0);
(void) duk_push_c_lightfunc(ctx, NULL, 0, 0, 0);
(void) duk_push_context_dump(ctx);
(void) duk_push_current_function(ctx);
(void) duk_push_current_thread(ctx);
(void) duk_push_dynamic_buffer(ctx, 0);
(void) duk_push_error_object_va(ctx, 0, NULL, NULL);
(void) duk_push_error_object(ctx, 0, "dummy");
(void) duk_push_external_buffer(ctx);
(void) duk_push_false(ctx);
(void) duk_push_fixed_buffer(ctx, 0);
(void) duk_push_global_object(ctx);
(void) duk_push_global_stash(ctx);
(void) duk_push_heap_stash(ctx);
(void) duk_push_heapptr(ctx, NULL);
(void) duk_push_int(ctx, 0);
(void) duk_push_lstring(ctx, "dummy", 0);
(void) duk_push_nan(ctx);
(void) duk_push_null(ctx);
(void) duk_push_number(ctx, 0.0);
(void) duk_push_object(ctx);
(void) duk_push_pointer(ctx, NULL);
(void) duk_push_sprintf(ctx, "dummy");
(void) duk_push_string(ctx, "dummy");
(void) duk_push_this(ctx);
(void) duk_push_thread_new_globalenv(ctx);
(void) duk_push_thread_stash(ctx, NULL);
(void) duk_push_thread(ctx);
(void) duk_push_true(ctx);
(void) duk_push_uint(ctx, 0);
(void) duk_push_undefined(ctx);
(void) duk_push_vsprintf(ctx, "dummy", NULL);
(void) duk_put_function_list(ctx, 0, NULL);
(void) duk_put_global_string(ctx, NULL);
(void) duk_put_number_list(ctx, 0, NULL);
(void) duk_put_prop_index(ctx, 0, 0);
(void) duk_put_prop_string(ctx, 0, "dummy");
(void) duk_put_prop(ctx, 0);
(void) duk_realloc_raw(ctx, NULL, 0);
(void) duk_realloc(ctx, NULL, 0);
(void) duk_remove(ctx, 0);
(void) duk_replace(ctx, 0);
(void) duk_require_boolean(ctx, 0);
(void) duk_require_buffer_data(ctx, 0, NULL);
(void) duk_require_buffer(ctx, 0, NULL);
(void) duk_require_c_function(ctx, 0);
(void) duk_require_callable(ctx, 0);
(void) duk_require_context(ctx, 0);
(void) duk_require_function(ctx, 0);
(void) duk_require_heapptr(ctx, 0);
(void) duk_require_int(ctx, 0);
(void) duk_require_lstring(ctx, 0, NULL);
(void) duk_require_normalize_index(ctx, 0);
(void) duk_require_null(ctx, 0);
(void) duk_require_number(ctx, 0);
(void) duk_require_object_coercible(ctx, 0);
(void) duk_require_pointer(ctx, 0);
(void) duk_require_stack_top(ctx, 0);
(void) duk_require_stack(ctx, 0);
(void) duk_require_string(ctx, 0);
(void) duk_require_top_index(ctx);
(void) duk_require_type_mask(ctx, 0, 0);
(void) duk_require_uint(ctx, 0);
(void) duk_require_undefined(ctx, 0);
(void) duk_require_valid_index(ctx, 0);
(void) duk_resize_buffer(ctx, 0, 0);
(void) duk_safe_call(ctx, NULL, NULL, 0, 0);
(void) duk_safe_to_lstring(ctx, 0, NULL);
(void) duk_safe_to_string(ctx, 0);
(void) duk_set_finalizer(ctx, 0);
(void) duk_set_global_object(ctx);
(void) duk_set_magic(ctx, 0, 0);
(void) duk_set_prototype(ctx, 0);
(void) duk_set_top(ctx, 0);
(void) duk_steal_buffer(ctx, 0, NULL);
(void) duk_strict_equals(ctx, 0, 0);
(void) duk_substring(ctx, 0, 0, 0);
(void) duk_swap_top(ctx, 0);
(void) duk_swap(ctx, 0, 0);
(void) duk_throw(ctx);
(void) duk_to_boolean(ctx, 0);
(void) duk_to_buffer(ctx, 0, NULL);
(void) duk_to_defaultvalue(ctx, 0, 0);
(void) duk_to_dynamic_buffer(ctx, 0, NULL);
(void) duk_to_fixed_buffer(ctx, 0, NULL);
(void) duk_to_int32(ctx, 0);
(void) duk_to_int(ctx, 0);
(void) duk_to_lstring(ctx, 0, NULL);
(void) duk_to_null(ctx, 0);
(void) duk_to_number(ctx, 0);
(void) duk_to_object(ctx, 0);
(void) duk_to_pointer(ctx, 0);
(void) duk_to_primitive(ctx, 0, 0);
(void) duk_to_string(ctx, 0);
(void) duk_to_uint16(ctx, 0);
(void) duk_to_uint32(ctx, 0);
(void) duk_to_uint(ctx, 0);
(void) duk_to_undefined(ctx, 0);
(void) duk_trim(ctx, 0);
(void) duk_xcopy_top(ctx, NULL, 0);
(void) duk_xmove_top(ctx, NULL, 0);
printf("never here\n"); fflush(stdout);
return 0;
}
static VALUE ctx_stack_to_value(struct state *state, int index)
{
duk_context *ctx = state->ctx;
size_t len;
const char *buf;
int type;
state->was_complex = 0;
type = duk_get_type(ctx, index);
switch (type) {
case DUK_TYPE_NULL:
case DUK_TYPE_UNDEFINED:
return Qnil;
case DUK_TYPE_NUMBER:
return rb_float_new(duk_get_number(ctx, index));
case DUK_TYPE_BOOLEAN:
return duk_get_boolean(ctx, index) ? Qtrue : Qfalse;
case DUK_TYPE_STRING:
buf = duk_get_lstring(ctx, index, &len);
VALUE str = rb_str_new(buf, len);
return decode_cesu8(state, str);
case DUK_TYPE_OBJECT:
if (duk_is_function(ctx, index)) {
state->was_complex = 1;
return state->complex_object;
} else if (duk_is_array(ctx, index)) {
VALUE ary = rb_ary_new();
duk_enum(ctx, index, DUK_ENUM_ARRAY_INDICES_ONLY);
while (duk_next(ctx, -1, 1)) {
rb_ary_store(ary, duk_to_int(ctx, -2), ctx_stack_to_value(state, -1));
duk_pop_2(ctx);
}
duk_pop(ctx);
return ary;
} else if (duk_is_object(ctx, index)) {
VALUE hash = rb_hash_new();
duk_enum(ctx, index, DUK_ENUM_OWN_PROPERTIES_ONLY);
while (duk_next(ctx, -1, 1)) {
VALUE key = ctx_stack_to_value(state, -2);
VALUE val = ctx_stack_to_value(state, -1);
duk_pop_2(ctx);
if (state->was_complex)
continue;
rb_hash_aset(hash, key, val);
}
duk_pop(ctx);
return hash;
} else {
state->was_complex = 1;
return state->complex_object;
}
case DUK_TYPE_BUFFER:
case DUK_TYPE_POINTER:
default:
return state->complex_object;
}
return Qnil;
}
void
_gum_duk_args_parse (const GumDukArgs * args,
const gchar * format,
...)
{
duk_context * ctx = args->ctx;
GumDukCore * core = args->core;
va_list ap;
duk_idx_t arg_index;
const gchar * t;
gboolean is_required;
GSList * byte_arrays = NULL;
const gchar * error_message = NULL;
va_start (ap, format);
arg_index = 0;
is_required = TRUE;
for (t = format; *t != '\0'; t++)
{
if (*t == '|')
{
is_required = FALSE;
continue;
}
if (arg_index >= duk_get_top (ctx) || duk_is_undefined (ctx, arg_index))
{
if (is_required)
goto missing_argument;
else
break;
}
switch (*t)
{
case 'i':
{
if (!duk_is_number (ctx, arg_index))
goto expected_int;
*va_arg (ap, gint *) = duk_require_int (ctx, arg_index);
break;
}
case 'u':
{
guint u;
if (!_gum_duk_get_uint (ctx, arg_index, &u))
goto expected_uint;
*va_arg (ap, guint *) = (guint) u;
break;
}
case 'q':
{
gint64 i;
gboolean is_fuzzy;
is_fuzzy = t[1] == '~';
if (is_fuzzy)
t++;
if (is_fuzzy)
{
if (!_gum_duk_parse_int64 (ctx, arg_index, core, &i))
goto expected_int;
}
else
{
if (!_gum_duk_get_int64 (ctx, arg_index, core, &i))
goto expected_int;
}
*va_arg (ap, gint64 *) = i;
break;
}
case 'Q':
{
guint64 u;
gboolean is_fuzzy;
is_fuzzy = t[1] == '~';
if (is_fuzzy)
t++;
if (is_fuzzy)
{
if (!_gum_duk_parse_uint64 (ctx, arg_index, core, &u))
goto expected_uint;
}
else
{
if (!_gum_duk_get_uint64 (ctx, arg_index, core, &u))
goto expected_uint;
}
*va_arg (ap, guint64 *) = u;
break;
}
case 'z':
{
gssize value;
if (duk_is_number (ctx, arg_index))
{
value = (gssize) duk_require_int (ctx, arg_index);
}
else
{
duk_push_heapptr (ctx, core->int64);
duk_push_heapptr (ctx, core->uint64);
if (duk_instanceof (ctx, arg_index, -2))
{
GumDukInt64 * object;
object = _gum_duk_require_data (ctx, arg_index);
value = (gssize) object->value;
}
else if (duk_instanceof (ctx, arg_index, -1))
{
GumDukUInt64 * object;
object = _gum_duk_require_data (ctx, arg_index);
value = (gssize) object->value;
}
else
{
goto expected_int;
}
duk_pop_2 (ctx);
}
*va_arg (ap, gssize *) = value;
break;
}
case 'Z':
{
gsize value;
if (duk_is_number (ctx, arg_index))
{
duk_double_t number;
number = duk_require_number (ctx, arg_index);
if (number < 0)
goto expected_uint;
value = (gsize) number;
}
else
{
duk_push_heapptr (ctx, core->int64);
duk_push_heapptr (ctx, core->uint64);
if (duk_instanceof (ctx, arg_index, -1))
{
GumDukUInt64 * object;
object = _gum_duk_require_data (ctx, arg_index);
value = (gsize) object->value;
}
else if (duk_instanceof (ctx, arg_index, -2))
{
GumDukInt64 * object;
object = _gum_duk_require_data (ctx, arg_index);
if (object->value < 0)
goto expected_uint;
value = (gsize) object->value;
}
else
{
goto expected_uint;
}
duk_pop_2 (ctx);
}
*va_arg (ap, gsize *) = value;
break;
}
case 'n':
{
if (!duk_is_number (ctx, arg_index))
goto expected_number;
*va_arg (ap, gdouble *) = duk_require_number (ctx, arg_index);
break;
}
case 'p':
{
gpointer ptr;
gboolean is_fuzzy;
is_fuzzy = t[1] == '~';
if (is_fuzzy)
t++;
if (is_fuzzy)
{
if (!_gum_duk_parse_pointer (ctx, arg_index, core, &ptr))
goto expected_pointer;
}
else
{
if (!_gum_duk_get_pointer (ctx, arg_index, core, &ptr))
goto expected_pointer;
}
*va_arg (ap, gpointer *) = ptr;
break;
}
case 's':
{
const gchar * str;
gboolean is_nullable;
is_nullable = t[1] == '?';
if (is_nullable)
t++;
if (is_nullable && duk_is_null (ctx, arg_index))
str = NULL;
else if ((str = duk_get_string (ctx, arg_index)) == NULL)
goto expected_string;
*va_arg (ap, const gchar **) = str;
break;
}
case 'm':
{
GumPageProtection prot;
if (!_gum_duk_parse_protection (ctx, arg_index, &prot))
goto expected_protection;
*va_arg (ap, GumPageProtection *) = prot;
break;
}
case 'V':
{
GumDukHeapPtr value;
value = duk_get_heapptr (ctx, arg_index);
if (value == NULL)
goto expected_heap_pointer;
*va_arg (ap, GumDukHeapPtr *) = value;
break;
}
case 'O':
{
if (!duk_is_object (ctx, arg_index))
goto expected_object;
*va_arg (ap, GumDukHeapPtr *) = duk_require_heapptr (ctx, arg_index);
break;
}
case 'A':
{
GumDukHeapPtr array;
gboolean is_nullable;
is_nullable = t[1] == '?';
if (is_nullable)
t++;
if (duk_is_array (ctx, arg_index))
array = duk_require_heapptr (ctx, arg_index);
else if (is_nullable && duk_is_null (ctx, arg_index))
array = NULL;
else
goto expected_array;
*va_arg (ap, GumDukHeapPtr *) = array;
break;
}
case 'F':
{
GumDukHeapPtr func;
gboolean is_expecting_object, is_nullable;
is_expecting_object = t[1] == '{';
if (is_expecting_object)
t += 2;
if (is_expecting_object)
{
const gchar * next, * end, * t_end;
if (!duk_is_object (ctx, arg_index))
goto expected_callback_object;
do
{
gchar name[64];
gsize length;
next = strchr (t, ',');
end = strchr (t, '}');
t_end = (next != NULL && next < end) ? next : end;
length = t_end - t;
strncpy (name, t, length);
is_nullable = name[length - 1] == '?';
if (is_nullable)
name[length - 1] = '\0';
else
name[length] = '\0';
duk_get_prop_string (ctx, arg_index, name);
if (duk_is_function (ctx, -1))
{
func = duk_require_heapptr (ctx, -1);
}
else if (is_nullable && duk_is_null_or_undefined (ctx, -1))
{
func = NULL;
}
else
{
duk_pop (ctx);
goto expected_callback_value;
}
duk_pop (ctx);
*va_arg (ap, GumDukHeapPtr *) = func;
t = t_end + 1;
}
while (t_end != end);
t--;
}
else
{
is_nullable = t[1] == '?';
if (is_nullable)
t++;
if (duk_is_function (ctx, arg_index))
func = duk_require_heapptr (ctx, arg_index);
else if (is_nullable && duk_is_null (ctx, arg_index))
func = NULL;
else
goto expected_function;
*va_arg (ap, GumDukHeapPtr *) = func;
}
break;
}
case 'B':
{
GBytes * bytes;
gboolean is_nullable;
is_nullable = t[1] == '?';
if (is_nullable)
t++;
if (is_nullable && duk_is_null (ctx, arg_index))
bytes = NULL;
else if (!_gum_duk_parse_bytes (ctx, arg_index, &bytes))
goto expected_bytes;
*va_arg (ap, GBytes **) = bytes;
if (bytes != NULL)
byte_arrays = g_slist_prepend (byte_arrays, bytes);
break;
}
case 'C':
{
GumCpuContext * cpu_context;
gboolean is_nullable;
is_nullable = t[1] == '?';
if (is_nullable)
t++;
if (is_nullable && duk_is_null (ctx, arg_index))
cpu_context = NULL;
else if ((cpu_context = _gum_duk_get_cpu_context (ctx, arg_index,
core)) == NULL)
goto expected_cpu_context;
*va_arg (ap, GumCpuContext **) = cpu_context;
break;
}
default:
g_assert_not_reached ();
}
arg_index++;
}
va_end (ap);
g_slist_free (byte_arrays);
return;
missing_argument:
{
error_message = "missing argument";
goto error;
}
expected_int:
{
error_message = "expected an integer";
goto error;
}
expected_uint:
{
error_message = "expected an unsigned integer";
goto error;
}
expected_number:
{
error_message = "expected a number";
goto error;
}
expected_pointer:
{
error_message = "expected a pointer";
goto error;
}
expected_string:
{
error_message = "expected a string";
goto error;
}
expected_protection:
{
error_message = "expected a string specifying memory protection";
goto error;
}
expected_heap_pointer:
{
error_message = "expected a heap-allocated object";
goto error;
}
expected_object:
{
error_message = "expected an object";
goto error;
}
expected_array:
{
error_message = "expected an array";
goto error;
}
expected_callback_object:
{
error_message = "expected an object containing callbacks";
goto error;
}
expected_callback_value:
{
error_message = "expected a callback value";
goto error;
}
expected_function:
{
error_message = "expected a function";
goto error;
}
expected_bytes:
{
error_message = "expected a buffer-like object";
goto error;
}
expected_cpu_context:
{
error_message = "expected a CpuContext object";
goto error;
}
error:
{
va_end (ap);
g_slist_foreach (byte_arrays, (GFunc) g_bytes_unref, NULL);
g_slist_free (byte_arrays);
g_assert (error_message != NULL);
_gum_duk_throw (ctx, error_message);
}
}
int duk_bi_array_prototype_iter_shared(duk_context *ctx) {
int len;
int i;
int k;
int bval;
int iter_type = duk_get_magic(ctx);
duk_uint32_t res_length = 0;
/* each call this helper serves has nargs==2 */
DUK_ASSERT_TOP(ctx, 2);
len = duk__push_this_obj_len_u32(ctx);
if (!duk_is_callable(ctx, 0)) {
goto type_error;
}
/* if thisArg not supplied, behave as if undefined was supplied */
if (iter_type == DUK__ITER_MAP || iter_type == DUK__ITER_FILTER) {
duk_push_array(ctx);
} else {
duk_push_undefined(ctx);
}
/* stack[0] = callback
* stack[1] = thisArg
* stack[2] = object
* stack[3] = ToUint32(length) (unused, but avoid unnecessary pop)
* stack[4] = result array (or undefined)
*/
k = 0; /* result index for filter() */
for (i = 0; i < len; i++) {
DUK_ASSERT_TOP(ctx, 5);
if (!duk_get_prop_index(ctx, 2, i)) {
duk_pop(ctx);
continue;
}
/* The original value needs to be preserved for filter(), hence
* this funny order. We can't re-get the value because of side
* effects.
*/
duk_dup(ctx, 0);
duk_dup(ctx, 1);
duk_dup(ctx, -3);
duk_push_int(ctx, i);
duk_dup(ctx, 2); /* [ ... val callback thisArg val i obj ] */
duk_call_method(ctx, 3); /* -> [ ... val retval ] */
switch (iter_type) {
case DUK__ITER_EVERY:
bval = duk_to_boolean(ctx, -1);
if (!bval) {
/* stack top contains 'false' */
return 1;
}
break;
case DUK__ITER_SOME:
bval = duk_to_boolean(ctx, -1);
if (bval) {
/* stack top contains 'true' */
return 1;
}
break;
case DUK__ITER_FOREACH:
/* nop */
break;
case DUK__ITER_MAP:
duk_dup(ctx, -1);
duk_def_prop_index(ctx, 4, i, DUK_PROPDESC_FLAGS_WEC); /* retval to result[i] */
res_length = i + 1;
break;
case DUK__ITER_FILTER:
bval = duk_to_boolean(ctx, -1);
if (bval) {
duk_dup(ctx, -2); /* orig value */
duk_def_prop_index(ctx, 4, k, DUK_PROPDESC_FLAGS_WEC);
k++;
res_length = k;
}
break;
default:
DUK_UNREACHABLE();
break;
}
duk_pop_2(ctx);
DUK_ASSERT_TOP(ctx, 5);
}
switch (iter_type) {
case DUK__ITER_EVERY:
duk_push_true(ctx);
break;
case DUK__ITER_SOME:
duk_push_false(ctx);
break;
case DUK__ITER_FOREACH:
duk_push_undefined(ctx);
break;
case DUK__ITER_MAP:
case DUK__ITER_FILTER:
DUK_ASSERT_TOP(ctx, 5);
DUK_ASSERT(duk_is_array(ctx, -1)); /* topmost element is the result array already */
duk_push_number(ctx, (double) res_length); /* FIXME */
duk_def_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
break;
default:
DUK_UNREACHABLE();
break;
}
return 1;
type_error:
return DUK_RET_TYPE_ERROR;
}
void test(duk_context *ctx) {
duk_idx_t i, n;
/*
* push test values
*/
/* 0 */
duk_push_undefined(ctx);
/* 1 */
duk_push_null(ctx);
/* 2 */
duk_push_true(ctx);
/* 3 */
duk_push_false(ctx);
/* 4 */
duk_push_int(ctx, 123);
/* 5 */
duk_push_number(ctx, 123.4);
/* 6 */
duk_push_nan(ctx);
/* 7 */
duk_push_number(ctx, INFINITY);
/* 8 */
duk_push_number(ctx, -INFINITY);
/* 9 */
duk_push_string(ctx, "");
/* 10 */
duk_push_string(ctx, "foo");
/* 11 */
duk_push_object(ctx);
/* 12 */
duk_push_array(ctx);
/* 13 */
duk_push_c_function(ctx, my_c_func, DUK_VARARGS);
/* 14 */
duk_push_string(ctx, "(function() { print('hello'); })");
duk_eval(ctx);
/* 15 */
duk_push_string(ctx, "escape.bind(null, 'foo')");
duk_eval(ctx);
/* 16 */
duk_push_thread(ctx);
/* 17 */
duk_push_buffer(ctx, 1024, 0 /*dynamic*/);
/* 18 */
duk_push_buffer(ctx, 1024, 1 /*dynamic*/);
/* 19 */
duk_push_pointer(ctx, (void *) 0xf00);
/*
* call checkers for each
*/
n = duk_get_top(ctx);
for (i = 0; i < n; i++) {
printf("%02ld: ", (long) i);
printf(" und=%d", (int) duk_is_undefined(ctx, i));
printf(" null=%d", (int) duk_is_null(ctx, i));
printf(" noru=%d", (int) duk_is_null_or_undefined(ctx, i));
printf(" bool=%d", (int) duk_is_boolean(ctx, i));
printf(" num=%d", (int) duk_is_number(ctx, i));
printf(" nan=%d", (int) duk_is_nan(ctx, i));
printf(" str=%d", (int) duk_is_string(ctx, i));
printf(" obj=%d", (int) duk_is_object(ctx, i));
printf(" arr=%d", (int) duk_is_array(ctx, i));
printf(" fun=%d", (int) duk_is_function(ctx, i));
printf(" cfun=%d", (int) duk_is_c_function(ctx, i));
printf(" efun=%d", (int) duk_is_ecmascript_function(ctx, i));
printf(" bfun=%d", (int) duk_is_bound_function(ctx, i));
printf(" call=%d", (int) duk_is_callable(ctx, i));
printf(" thr=%d", (int) duk_is_thread(ctx, i));
printf(" buf=%d", (int) duk_is_buffer(ctx, i));
printf(" dyn=%d", (int) duk_is_dynamic_buffer(ctx, i));
printf(" fix=%d", (int) duk_is_fixed_buffer(ctx, i));
printf(" ptr=%d", (int) duk_is_pointer(ctx, i));
printf(" prim=%d", (int) duk_is_primitive(ctx, i));
printf(" objcoerc=%d", (int) duk_is_object_coercible(ctx, i));
printf("\n");
}
}
bool StyleContext::parseStyleResult(StyleParamKey _key, StyleParam::Value& _val) const {
_val = none_type{};
if (duk_is_string(m_ctx, -1)) {
std::string value(duk_get_string(m_ctx, -1));
_val = StyleParam::parseString(_key, value);
} else if (duk_is_boolean(m_ctx, -1)) {
bool value = duk_get_boolean(m_ctx, -1);
switch (_key) {
case StyleParamKey::visible:
_val = value;
break;
case StyleParamKey::extrude:
_val = value ? glm::vec2(NAN, NAN) : glm::vec2(0.0f, 0.0f);
break;
default:
break;
}
} else if (duk_is_array(m_ctx, -1)) {
duk_get_prop_string(m_ctx, -1, "length");
int len = duk_get_int(m_ctx, -1);
duk_pop(m_ctx);
switch (_key) {
case StyleParamKey::extrude: {
if (len != 2) {
logMsg("Warning: Wrong array size for extrusion: '%d'.\n", len);
break;
}
duk_get_prop_index(m_ctx, -1, 0);
double v1 = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 1);
double v2 = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
_val = glm::vec2(v1, v2);
break;
}
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::font_fill:
case StyleParamKey::font_stroke:
case StyleParamKey::font_stroke_color: {
if (len < 3 || len > 4) {
logMsg("Warning: Wrong array size for color: '%d'.\n", len);
break;
}
duk_get_prop_index(m_ctx, -1, 0);
double r = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 1);
double g = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 2);
double b = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
double a = 1.0;
if (len == 4) {
duk_get_prop_index(m_ctx, -1, 3);
a = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
}
_val = (((uint32_t)(255.0 * a) & 0xff) << 24) |
(((uint32_t)(255.0 * r) & 0xff)<< 16) |
(((uint32_t)(255.0 * g) & 0xff)<< 8) |
(((uint32_t)(255.0 * b) & 0xff));
break;
}
default:
break;
}
} else if (duk_is_number(m_ctx, -1)) {
switch (_key) {
case StyleParamKey::width:
case StyleParamKey::outline_width:
case StyleParamKey::font_stroke_width: {
double v = duk_get_number(m_ctx, -1);
_val = static_cast<float>(v);
break;
}
case StyleParamKey::order:
case StyleParamKey::priority:
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::font_fill:
case StyleParamKey::font_stroke:
case StyleParamKey::font_stroke_color: {
_val = static_cast<uint32_t>(duk_get_uint(m_ctx, -1));
break;
}
default:
break;
}
} else {
logMsg("Warning: Unhandled return type from Javascript function.\n");
}
duk_pop(m_ctx);
DUMP("parseStyleResult\n");
return !_val.is<none_type>();
}
//-----------------------------------------------------------------------------
void AdTiledManager::Load(const char* pName) {
Unload();
char pFN[FILENAME_MAX];
sprintf(pFN, MAP_LOCATION, pName);
duk_context* ctx = s_pJSCtx;
duk_push_string_file(ctx, pFN);
duk_json_decode(ctx, -1);
if(!duk_is_object(ctx, -1)) {
fprintf(stderr, "NOTE: Failed parse %s.json!\n", pName);
return;
}
duk_get_prop_string(ctx, -1, "width");
m_iWidth = duk_to_int(ctx, -1);
duk_pop(ctx);
duk_get_prop_string(ctx, -1, "height");
m_iHeight = duk_to_int(ctx, -1);
duk_pop(ctx);
duk_get_prop_string(ctx, -1, "layers");
if(duk_is_array(ctx, -1)) {
m_nLayers = duk_get_length(ctx, -1);
m_pIndices = (int**) calloc(m_nLayers, sizeof(int*));
for(int j=0; j<m_nLayers; ++j) {
duk_get_prop_index(ctx, -1, j);
// NOTE: if this is a tile layer grab the indices, otherwise set
// to NULL
duk_get_prop_string(ctx, -1, "data");
if(duk_is_array(ctx, -1)) {
int size = duk_get_length(ctx, -1);
if((m_iWidth*m_iHeight) == size) {
m_pIndices[j] = (int*) malloc(size*sizeof(int));
for(int i=0; i<size; ++i) {
duk_get_prop_index(ctx, -1, i);
m_pIndices[j][i] = duk_to_int(ctx, -1);
duk_pop(ctx);
}
}
}
duk_pop(ctx);
// NOTE: loop over the map entities and add them to the array of
// entities
duk_get_prop_string(ctx, -1, "name");
if(duk_is_string(ctx, -1)) {
if(!strcmp(duk_get_string(ctx, -1), "entities")) {
// NOTE: -2 referring back to object and not the string
duk_get_prop_string(ctx, -2, "objects");
if(duk_is_array(ctx, -1)) {
int size = duk_get_length(ctx, -1);
for(int e=0; e<size; ++e) {
duk_get_prop_index(ctx, -1, e);
duk_get_prop_string(ctx, -1, "type");
const char* type = duk_get_string(ctx, -1);
AdEntity* pEnt = NULL;
if(!strcmp(type, "NPC-TEST")) {
duk_pop(ctx);
pEnt = new NpcTree0();
pEnt->Load(ctx);
} else if(!strcmp(type, "NPC-RON")) {
duk_pop(ctx);
pEnt = new NpcRon();
pEnt->Load(ctx);
} else if(!strcmp(type, "NPC-PYTHON")) {
duk_pop(ctx);
pEnt = new NpcPython();
pEnt->Load(ctx);
} else if(!strcmp(type, "NPC-BURRITO")) {
duk_pop(ctx);
pEnt = new NpcBurrito();
pEnt->Load(ctx);
} else if(!strcmp(type, "NPC-JAVALS")) {
duk_pop(ctx);
pEnt = new NpcJavals();
pEnt->Load(ctx);
} else if(!strcmp(type, "NPC-GWEN")) {
duk_pop(ctx);
pEnt = new NpcGwen();
pEnt->Load(ctx);
} else if(!strcmp(type, "NPC-AVOCADO")) {
duk_pop(ctx);
pEnt = new NpcAvocado();
pEnt->Load(ctx);
} else if(!strcmp(type, "NPC-PUZZLE_PIECE")) {
duk_pop(ctx);
pEnt = new NpcPuzzlePiece();
pEnt->Load(ctx);
} else if(!strcmp(type, "NPC-PUZZLE_PIECE2")) {
duk_pop(ctx);
pEnt = new NpcPuzzlePiece2();
pEnt->Load(ctx);
} else if(!strcmp(type, "NPC-STATUE_BASE")) {
duk_pop(ctx);
pEnt = new NpcStatueBase();
pEnt->Load(ctx);
} else if(
!strcmp(type, "LVL-UP-0") ||
!strcmp(type, "LVL-DOWN-0") ||
!strcmp(type, "LVL-LEFT-0") ||
!strcmp(type, "LVL-RIGHT-0")
) {
duk_pop(ctx);
pEnt = new AdEntity();
pEnt->Load(ctx);
} else {
duk_pop(ctx);
}
if(pEnt) {
m_pEntities = (AdEntity**) realloc(
m_pEntities, ++m_nEntities*sizeof(AdEntity*)
); m_pEntities[m_nEntities-1] = pEnt;
}
duk_pop(ctx);
}
}
duk_pop(ctx);
}
}
duk_pop_2(ctx);
}
}
duk_pop_2(ctx);
}
void StyleContext::parseStyleResult(StyleParamKey _key, StyleParam::Value& _val) const {
_val = none_type{};
if (duk_is_string(m_ctx, -1)) {
std::string value(duk_get_string(m_ctx, -1));
_val = StyleParam::parseString(_key, value);
} else if (duk_is_boolean(m_ctx, -1)) {
bool value = duk_get_boolean(m_ctx, -1);
switch (_key) {
case StyleParamKey::interactive:
case StyleParamKey::text_interactive:
case StyleParamKey::visible:
_val = value;
break;
case StyleParamKey::extrude:
_val = value ? glm::vec2(NAN, NAN) : glm::vec2(0.0f, 0.0f);
break;
default:
break;
}
} else if (duk_is_array(m_ctx, -1)) {
duk_get_prop_string(m_ctx, -1, "length");
int len = duk_get_int(m_ctx, -1);
duk_pop(m_ctx);
switch (_key) {
case StyleParamKey::extrude: {
if (len != 2) {
LOGW("Wrong array size for extrusion: '%d'.", len);
break;
}
duk_get_prop_index(m_ctx, -1, 0);
double v1 = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 1);
double v2 = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
_val = glm::vec2(v1, v2);
break;
}
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::text_font_fill:
case StyleParamKey::text_font_stroke_color: {
if (len < 3 || len > 4) {
LOGW("Wrong array size for color: '%d'.", len);
break;
}
duk_get_prop_index(m_ctx, -1, 0);
double r = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 1);
double g = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 2);
double b = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
double a = 1.0;
if (len == 4) {
duk_get_prop_index(m_ctx, -1, 3);
a = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
}
_val = (((uint32_t)(255.0 * a) & 0xff) << 24) |
(((uint32_t)(255.0 * r) & 0xff)<< 16) |
(((uint32_t)(255.0 * g) & 0xff)<< 8) |
(((uint32_t)(255.0 * b) & 0xff));
break;
}
default:
break;
}
} else if (duk_is_nan(m_ctx, -1)) {
// Ignore setting value
LOGD("duk evaluates JS method to NAN.\n");
} else if (duk_is_number(m_ctx, -1)) {
switch (_key) {
case StyleParamKey::extrude:
_val = glm::vec2(0.f, static_cast<float>(duk_get_number(m_ctx, -1)));
break;
case StyleParamKey::width:
case StyleParamKey::outline_width: {
// TODO more efficient way to return pixels.
// atm this only works by return value as string
double v = duk_get_number(m_ctx, -1);
_val = StyleParam::Width{static_cast<float>(v)};
break;
}
case StyleParamKey::text_font_stroke_width: {
_val = static_cast<float>(duk_get_number(m_ctx, -1));
break;
}
case StyleParamKey::order:
case StyleParamKey::outline_order:
case StyleParamKey::priority:
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::text_font_fill:
case StyleParamKey::text_font_stroke_color: {
_val = static_cast<uint32_t>(duk_get_uint(m_ctx, -1));
break;
}
default:
break;
}
} else if (duk_is_null_or_undefined(m_ctx, -1)) {
// Ignore setting value
LOGD("duk evaluates JS method to null or undefined.");
} else {
LOGW("Unhandled return type from Javascript style function for %d.", _key);
}
DUMP("parseStyleResult\n");
}
DUK_INTERNAL duk_ret_t duk_bi_array_prototype_iter_shared(duk_context *ctx) {
duk_uint32_t len;
duk_uint32_t i;
duk_uarridx_t k;
duk_bool_t bval;
duk_small_int_t iter_type = duk_get_current_magic(ctx);
duk_uint32_t res_length = 0;
/* each call this helper serves has nargs==2 */
DUK_ASSERT_TOP(ctx, 2);
len = duk__push_this_obj_len_u32(ctx);
duk_require_callable(ctx, 0);
/* if thisArg not supplied, behave as if undefined was supplied */
if (iter_type == DUK__ITER_MAP || iter_type == DUK__ITER_FILTER) {
duk_push_array(ctx);
} else {
duk_push_undefined(ctx);
}
/* stack[0] = callback
* stack[1] = thisArg
* stack[2] = object
* stack[3] = ToUint32(length) (unused, but avoid unnecessary pop)
* stack[4] = result array (or undefined)
*/
k = 0; /* result index for filter() */
for (i = 0; i < len; i++) {
DUK_ASSERT_TOP(ctx, 5);
if (!duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) {
#if defined(DUK_USE_NONSTD_ARRAY_MAP_TRAILER)
/* Real world behavior for map(): trailing non-existent
* elements don't invoke the user callback, but are still
* counted towards result 'length'.
*/
if (iter_type == DUK__ITER_MAP) {
res_length = i + 1;
}
#else
/* Standard behavior for map(): trailing non-existent
* elements don't invoke the user callback and are not
* counted towards result 'length'.
*/
#endif
duk_pop(ctx);
continue;
}
/* The original value needs to be preserved for filter(), hence
* this funny order. We can't re-get the value because of side
* effects.
*/
duk_dup(ctx, 0);
duk_dup(ctx, 1);
duk_dup(ctx, -3);
duk_push_u32(ctx, i);
duk_dup(ctx, 2); /* [ ... val callback thisArg val i obj ] */
duk_call_method(ctx, 3); /* -> [ ... val retval ] */
switch (iter_type) {
case DUK__ITER_EVERY:
bval = duk_to_boolean(ctx, -1);
if (!bval) {
/* stack top contains 'false' */
return 1;
}
break;
case DUK__ITER_SOME:
bval = duk_to_boolean(ctx, -1);
if (bval) {
/* stack top contains 'true' */
return 1;
}
break;
case DUK__ITER_FOREACH:
/* nop */
break;
case DUK__ITER_MAP:
duk_dup(ctx, -1);
duk_xdef_prop_index_wec(ctx, 4, (duk_uarridx_t) i); /* retval to result[i] */
res_length = i + 1;
break;
case DUK__ITER_FILTER:
bval = duk_to_boolean(ctx, -1);
if (bval) {
duk_dup(ctx, -2); /* orig value */
duk_xdef_prop_index_wec(ctx, 4, (duk_uarridx_t) k);
k++;
res_length = k;
}
break;
default:
DUK_UNREACHABLE();
break;
}
duk_pop_2(ctx);
DUK_ASSERT_TOP(ctx, 5);
}
switch (iter_type) {
case DUK__ITER_EVERY:
duk_push_true(ctx);
break;
case DUK__ITER_SOME:
duk_push_false(ctx);
break;
case DUK__ITER_FOREACH:
duk_push_undefined(ctx);
break;
case DUK__ITER_MAP:
case DUK__ITER_FILTER:
DUK_ASSERT_TOP(ctx, 5);
DUK_ASSERT(duk_is_array(ctx, -1)); /* topmost element is the result array already */
duk_push_u32(ctx, res_length);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
break;
default:
DUK_UNREACHABLE();
break;
}
return 1;
}
//-----------------------------------------------------------------------------
void AdTiledManager::Load(const char* pName) {
Unload();
char pFN[FILENAME_MAX];
sprintf(pFN, MAP_LOCATION, pName);
duk_context* ctx = s_pJSCtx;
duk_push_string_file(ctx, pFN);
duk_json_decode(ctx, -1);
if(!duk_is_object(ctx, -1)) {
fprintf(stderr, "NOTE: Failed parse %s.json!\n", pName);
return;
}
duk_get_prop_string(ctx, -1, "width");
m_iWidth = duk_to_int(ctx, -1);
duk_pop(ctx);
duk_get_prop_string(ctx, -1, "height");
m_iHeight = duk_to_int(ctx, -1);
duk_pop(ctx);
duk_get_prop_string(ctx, -1, "layers");
if(duk_is_array(ctx, -1)) {
m_nLayers = duk_get_length(ctx, -1);
m_pIndices = (int**) calloc(m_nLayers, sizeof(int*));
for(int j=0; j<m_nLayers; ++j) {
duk_get_prop_index(ctx, -1, j);
// NOTE: if this is a tile layer grab the indices, otherwise set
// to NULL
duk_get_prop_string(ctx, -1, "data");
if(duk_is_array(ctx, -1)) {
int size = duk_get_length(ctx, -1);
if((m_iWidth*m_iHeight) == size) {
m_pIndices[j] = (int*) malloc(size*sizeof(int));
for(int i=0; i<size; ++i) {
duk_get_prop_index(ctx, -1, i);
m_pIndices[j][i] = duk_to_int(ctx, -1);
duk_pop(ctx);
}
}
}
duk_pop(ctx);
// NOTE: loop over the map entities and add them to the array of
// entities
duk_get_prop_string(ctx, -1, "name");
if(duk_is_string(ctx, -1)) {
if(!strcmp(duk_get_string(ctx, -1), "entities")) {
// NOTE: -2 referring back to object and not the string
duk_get_prop_string(ctx, -2, "objects");
if(duk_is_array(ctx, -1)) {
int size = duk_get_length(ctx, -1);
for(int e=0; e<size; ++e) {
duk_get_prop_index(ctx, -1, e);
duk_get_prop_string(ctx, -1, "type");
const char* type = duk_get_string(ctx, -1);
AdEntity* pEnt = NULL;
if(!strcmp(type, "NPC-PLAYER")) {
duk_pop(ctx);
pEnt = new AdPlayer();
pEnt->Load(ctx);
} else if(!strcmp(type, "NPC-TEST")) {
duk_pop(ctx);
pEnt = new AdMoveable();
pEnt->Load(ctx);
} else if(!strcmp(type, "TEST")) {
duk_pop(ctx);
pEnt = new AdEntity();
pEnt->Load(ctx);
} else {
duk_pop(ctx);
}
if(pEnt) {
m_pEntities = (AdEntity**) realloc(
m_pEntities, ++m_nEntities*sizeof(AdEntity*)
); m_pEntities[m_nEntities-1] = pEnt;
}
duk_pop(ctx);
}
}
duk_pop(ctx);
}
}
duk_pop_2(ctx);
}
}
duk_pop_2(ctx);
}