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 gboolean
gum_duk_exception_handler_on_exception (GumExceptionDetails * details,
gpointer user_data)
{
GumDukExceptionHandler * handler = user_data;
GumDukCore * core = handler->core;
GumDukScope scope;
duk_context * ctx;
GumDukCpuContext * cpu_context;
gboolean handled = FALSE;
ctx = _gum_duk_scope_enter (&scope, core);
_gum_duk_push_exception_details (ctx, details, core, &cpu_context);
duk_push_heapptr (ctx, handler->callback);
duk_dup (ctx, -2);
if (_gum_duk_scope_call (&scope, 1))
{
if (duk_is_boolean (ctx, -1))
handled = duk_require_boolean (ctx, -1);
}
_gum_duk_cpu_context_make_read_only (cpu_context);
duk_pop_2 (ctx);
_gum_duk_scope_leave (&scope);
return handled;
}
bool StyleContext::evalFilter(FunctionID _id) const {
if (!duk_get_global_string(m_ctx, FUNC_ID)) {
logMsg("Error: evalFilterFn - functions not initialized\n");
return false;
}
if (!duk_get_prop_index(m_ctx, -1, _id)) {
logMsg("Error: evalFilterFn - function %d not set\n", _id);
}
if (duk_pcall(m_ctx, 0) != 0) {
logMsg("Error: evalFilterFn: %s\n", duk_safe_to_string(m_ctx, -1));
}
bool result = false;
if (duk_is_boolean(m_ctx, -1)) {
result = duk_get_boolean(m_ctx, -1);
}
// pop result
duk_pop(m_ctx);
// pop fns obj
duk_pop(m_ctx);
DUMP("evalFilterFn\n");
return result;
}
/* Shared helper to provide toString() and valueOf(). Checks 'this', gets
* the primitive value to stack top, and optionally coerces with ToString().
*/
duk_ret_t duk_bi_boolean_prototype_tostring_shared(duk_context *ctx) {
duk_tval *tv;
duk_hobject *h;
duk_small_int_t coerce_tostring = duk_get_magic(ctx);
/* FIXME: there is room to use a shared helper here, many built-ins
* check the 'this' type, and if it's an object, check its class,
* then get its internal value, etc.
*/
duk_push_this(ctx);
tv = duk_get_tval(ctx, -1);
DUK_ASSERT(tv != NULL);
if (DUK_TVAL_IS_BOOLEAN(tv)) {
goto type_ok;
} else if (DUK_TVAL_IS_OBJECT(tv)) {
h = DUK_TVAL_GET_OBJECT(tv);
DUK_ASSERT(h != NULL);
if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_BOOLEAN) {
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
DUK_ASSERT(duk_is_boolean(ctx, -1));
goto type_ok;
}
}
return DUK_RET_TYPE_ERROR;
type_ok:
if (coerce_tostring) {
duk_to_string(ctx, -1);
}
return 1;
}
/*
NOTE: might be a terrible idea to just exit but I suppose
the OS will clean up all resources. Might want to set
close to true by default?
*/
static duk_ret_t dukos_exit(duk_context *ctx) {
int status, close;
duk_bool_t success = duk_require_boolean(ctx, 0);
status = (success ? EXIT_SUCCESS : EXIT_FAILURE);
close = (duk_is_boolean(ctx, 1) ? duk_require_boolean(ctx, 1) : 0);
if (close) { duk_destroy_heap(ctx); }
if (ctx) exit(status); /* 'if' to avoid warnings for unreachable 'return' */
return 0;
}
bool jsplugin_load(JSVM* vm, const String& pluginLibrary)
{
String errorMsg;
atomic_plugin_validate_function validatefunc;
duk_c_function initfunc;
duk_context* ctx = vm->GetJSContext();
LOGINFOF("Loading Native Plugin: %s", pluginLibrary.CString());
if (!jsplugin_get_entry_points(pluginLibrary, &validatefunc, &initfunc, errorMsg))
{
LOGERRORF("%s", errorMsg.CString());
return false;
}
int version = ATOMIC_JSPLUGIN_VERSION;
if (!validatefunc(version, &gJSVMExports, sizeof(JSVMImports)))
{
LOGERRORF("Native Plugin: atomic_plugin_validate failed: %s", pluginLibrary.CString());
return false;
}
// just to verify that we're not doing anything funky with the stack
int top = duk_get_top(ctx);
// the import function is a standard duktape c function, neat
duk_push_c_function(ctx, initfunc, 1);
// requires exports to be at index 2
duk_dup(ctx, 2);
bool success = true;
if (duk_pcall(ctx, 1) != DUK_EXEC_SUCCESS)
{
success = false;
LOGERRORF("Native Plugin: error calling atomic_plugin_init %s", pluginLibrary.CString());
}
else
{
if (!duk_is_boolean(ctx, -1) || !duk_to_boolean(ctx, -1))
{
success = false;
LOGERRORF("Native Plugin: error calling atomic_plugin_init, didn't return true %s", pluginLibrary.CString());
}
}
duk_pop(ctx);
assert(top == duk_get_top(ctx));
return success;
}
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;
}
bool StyleContext::evalFilter(FunctionID _id) {
bool result = false;
if (!evalFunction(_id)) { return false; };
// check for evaluated value sitting at value stack top
if (duk_is_boolean(m_ctx, -1)) {
result = duk_get_boolean(m_ctx, -1);
}
// pop result
duk_pop(m_ctx);
return result;
}
static int
es_sqlite_query(duk_context *ctx)
{
int argc = duk_get_top(ctx);
if(argc < 2)
return DUK_RET_TYPE_ERROR;
es_sqlite_t *es = es_resource_get(ctx, 0, &es_resource_sqlite);
const char *query = duk_safe_to_string(ctx, 1);
if(es->es_stmt) {
sqlite3_finalize(es->es_stmt);
es->es_stmt = NULL;
}
int rc = db_prepare(es->es_db, &es->es_stmt, query);
if(rc != SQLITE_OK) {
if(es->es_transaction && rc == SQLITE_LOCKED)
duk_error(ctx, ST_ERROR_SQLITE_BASE | rc , "Deadlock");
duk_error(ctx, ST_ERROR_SQLITE_BASE | rc,
"Sqlite error 0x%x -- %s",
rc, sqlite3_errmsg(es->es_db));
}
sqlite3_stmt *stmt = es->es_stmt;
for(int i = 2; i < argc; i++) {
int sqlite_arg = i - 1;
if(duk_is_null_or_undefined(ctx, i)) {
sqlite3_bind_null(stmt, sqlite_arg);
} else if(duk_is_number(ctx, i)) {
sqlite3_bind_double(stmt, sqlite_arg, duk_get_number(ctx, i));
} else if(duk_is_boolean(ctx, i)) {
sqlite3_bind_int(stmt, sqlite_arg, duk_get_boolean(ctx, i));
} else {
sqlite3_bind_text(stmt, sqlite_arg, duk_safe_to_string(ctx, i),
-1, SQLITE_STATIC);
}
}
es_sqlite_stmt_step(ctx, es);
return 0;
}
bool StyleContext::evalFilterFn(const std::string& _name) {
if (!duk_get_global_string(m_ctx, _name.c_str())) {
logMsg("Error: evalFilter %s\n", _name.c_str());
return false;
}
if (duk_pcall(m_ctx, 0) != 0) {
logMsg("Error: evalFilterFn: %s\n", duk_safe_to_string(m_ctx, -1));
}
bool result = false;
if (duk_is_boolean(m_ctx, -1)) {
result = duk_get_boolean(m_ctx, -1);
}
// pop result
duk_pop(m_ctx);
DUMP("evalFilterFn\n");
return result;
}
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;
}
Variant GetVariant(duk_context* ctx, duk_idx_t stackIndex)
{
if (duk_is_boolean(ctx, stackIndex))
return Variant(duk_get_boolean(ctx, stackIndex) ? true : false);
if (duk_is_number(ctx, stackIndex))
return Variant(duk_get_number(ctx, stackIndex));
else if (duk_is_string(ctx, stackIndex))
return Variant(String(duk_get_string(ctx, stackIndex)));
else if (duk_is_object(ctx, stackIndex))
{
const char* objTypeName = GetValueObjectType(ctx, stackIndex);
if (objTypeName == float2_ID)
return Variant(Urho3D::Vector2(*GetValueObject<float2>(ctx, stackIndex, nullptr)));
else if (objTypeName == float3_ID)
return Variant(Urho3D::Vector3(*GetValueObject<float3>(ctx, stackIndex, nullptr)));
else if (objTypeName == float4_ID)
return Variant(Urho3D::Vector4(*GetValueObject<float4>(ctx, stackIndex, nullptr)));
else if (objTypeName == Quat_ID)
return Variant(Urho3D::Quaternion(*GetValueObject<Quat>(ctx, stackIndex, nullptr)));
}
/// \todo More types
return Variant();
}
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;
}
void JSEventHelper::HandleEvent(StringHash eventType, VariantMap& eventData)
{
if (object_.Null())
return;
JSVM* vm = JSVM::GetJSVM(0);
duk_context* ctx = vm->GetJSContext();
duk_idx_t top = duk_get_top(ctx);
js_push_class_object_instance(ctx, this);
duk_get_prop_string(ctx, -1, "__eventHelperFunctions");
assert(duk_is_object(ctx, -1));
duk_get_prop_string(ctx, -1, eventType.ToString().CString());
if (duk_is_function(ctx, -1))
{
// look in the variant map cache
duk_push_global_stash(ctx);
duk_get_prop_index(ctx, -1, JS_GLOBALSTASH_VARIANTMAP_CACHE);
duk_push_pointer(ctx, (void*) &eventData);
duk_get_prop(ctx, -2);
if (!duk_is_object(ctx, -1))
{
// pop result
duk_pop(ctx);
// we need to push a new variant map and store to cache
// the cache object will be cleared at the send end in the
// global listener above
js_push_variantmap(ctx, eventData);
duk_push_pointer(ctx, (void*) &eventData);
duk_dup(ctx, -2);
duk_put_prop(ctx, -4);
}
duk_remove(ctx, -2); // vmap cache
duk_remove(ctx, -2); // global stash
if (duk_pcall(ctx, 1) != 0)
{
vm->SendJSErrorEvent();
}
else
{
// For widget events, need to check return value
// and set whether handled
if (eventType == E_WIDGETEVENT)
{
if (duk_is_boolean(ctx, -1))
{
if (duk_to_boolean(ctx, -1))
{
eventData[WidgetEvent::P_HANDLED] = true;
}
}
}
}
}
duk_set_top(ctx, top);
}
//duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index);
duk_bool_t aperl_duk_is_boolean(duk_context *ctx, duk_idx_t index) {
duk_bool_t ret = duk_is_boolean(ctx, index);
return ret;
}
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>();
}
bool Context::isBool(index_t i)
{
return (duk_is_boolean(m_handle, i) ? true: false);
}
int8_t sendSms(duk_context *JsContext, InputParameters_t *Parameters, char *Input[])
{
extern const char const *ErrorMessages[];
extern HttpHandle_t *Handle;
extern Output_t OutputMessages;
int8_t RetCode = EXIT_SUCCESS;
char *GatewayLocation;
if (Parameters->GatewayLocation)
{
uint8_t GatewayLocationLength = strlen(Input[Parameters->GatewayLocation] );
if ( Input[Parameters->GatewayLocation][GatewayLocationLength - 1] == '/')
{
Input[Parameters->GatewayLocation][GatewayLocationLength - 1] = '\0';
GatewayLocationLength--;
}
// 10 = '/' + ".gateway" + '\0'
GatewayLocation = malloc(GatewayLocationLength + strlen(Input[Parameters->Gateway] ) + 10);
if (!GatewayLocation)
{
setErrorMsg(ErrorMessages[MEMORY], true);
return NO_MEMORY;
}
sprintf(GatewayLocation, "%s/%s.gateway",Input[Parameters->GatewayLocation], Input[Parameters->Gateway] );
}
else
{
// 27 = "/usr/share/esmska/" + ".gateway" + '\0'
GatewayLocation = malloc(strlen(Input[Parameters->Gateway] ) + 27);
if (!GatewayLocation)
{
setErrorMsg(ErrorMessages[MEMORY], true);
return NO_MEMORY;
}
sprintf(GatewayLocation, "/usr/share/esmska/%s.gateway", Input[Parameters->Gateway] );
}
if (duk_peval_file(JsContext, GatewayLocation) )
{
duk_get_prop_string(JsContext, -1, "message");
setErrorMsg(ErrorMessages[MODULE_PROCESSING], false);
setErrorMsg(Input[Parameters->Gateway], false);
setErrorMsg(duk_get_string(JsContext, -1), true);
free(GatewayLocation);
return MODULE_ERROR;
}
free(GatewayLocation);
duk_pop(JsContext); // Zahozeni vysledku (undefined)
// Zpristupneni potrebnych udaju jako username, passwd, cislo, text zpravy
duk_push_global_object(JsContext);
if (Parameters->User) duk_push_string(JsContext, Input[Parameters->User] );
else duk_push_string(JsContext, "");
duk_put_prop_string(JsContext, -2, "LOGIN");
if (Parameters->Password) duk_push_string(JsContext, Input[Parameters->Password] );
else duk_push_string(JsContext, "");
duk_put_prop_string(JsContext, -2, "PASSWORD");
if (Parameters->SenderNumber) duk_push_string(JsContext, Input[Parameters->SenderNumber] );
else duk_push_string(JsContext, "");
duk_put_prop_string(JsContext, -2, "SENDERNUMBER");
duk_push_string(JsContext, Input[Parameters->Number] );
duk_put_prop_string(JsContext, -2, "NUMBER");
duk_push_string(JsContext, Input[Parameters->Text] );
duk_put_prop_string(JsContext, -2, "MESSAGE");
if (duk_peval_string(JsContext, "RECEIPT = (getFeatures().indexOf('RECEIPT') > -1 ? true : false)") )
{
duk_get_prop_string(JsContext, -1, "message");
setErrorMsg(ErrorMessages[RECEIPT_SETTING], false);
setErrorMsg(duk_get_string(JsContext, -1), true);
return MODULE_ERROR;
}
duk_pop(JsContext);
// Zpristupneni potrebnych metod, promennych a samotny objekt EXEC
duk_push_object(JsContext);
duk_push_c_function(JsContext, get, 2);
duk_put_prop_string(JsContext, -2, "getURL");
duk_push_c_function(JsContext, post, 3);
duk_put_prop_string(JsContext, -2, "postURL");
duk_push_c_function(JsContext, setProblem, 2);
duk_put_prop_string(JsContext, -2, "setProblem");
duk_push_c_function(JsContext, setSupplementalMsg, 1);
duk_put_prop_string(JsContext, -2, "setSupplementalMessage");
duk_push_c_function(JsContext, stall, 1);
duk_put_prop_string(JsContext, -2, "sleep");
duk_push_c_function(JsContext, setReferer, 1);
duk_put_prop_string(JsContext, -2, "setReferer");
duk_push_string(JsContext, "Free SMS remaining: ");
duk_put_prop_string(JsContext, -2, "INFO_FREE_SMS_REMAINING");
duk_push_string(JsContext, "The gateway doesn't provide any information about successful sending. The message might be and might not be delivered.");
duk_put_prop_string(JsContext, -2, "INFO_STATUS_NOT_PROVIDED");
duk_push_string(JsContext, "Remaining credit: ");
duk_put_prop_string(JsContext, -2, "INFO_CREDIT_REMAINING");
duk_put_prop_string(JsContext, -2, "EXEC");
// Vytvoreni CURL contextu
if ( !(Handle = httpInit() ) )
{
setErrorMsg(ErrorMessages[NO_CURL_CONTEXT], true);
return CURL_ERROR;
}
// Volani funkce send()
duk_get_prop_string(JsContext, -1, "send");
if (duk_pcall(JsContext, 0) )
{
if (duk_is_number(JsContext, -1) )
{
uint8_t ErrCode = duk_get_number(JsContext, -1);
if (ErrCode < 90)
{
setErrorMsg(ErrorMessages[GENERIC], false);
setErrorMsg(curl_easy_strerror(ErrCode), true);
RetCode = CURL_ERROR;
}
else
{
OutputMessages.MessagesArray[OutputMessages.NextFree].MsgType = ERR;
OutputMessages.MessagesArray[OutputMessages.NextFree].IsEndOfMsg = 1;
switch (ErrCode)
{
case NO_MEMORY:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[MEMORY];
RetCode = INTERNAL_ERROR;
break;
case NO_POST_DATA:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[POST_DATA];
RetCode = MODULE_ERROR;
break;
case SET_PROBLEM_NO_MSG:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[NO_EXPLAINING];
RetCode = MODULE_ERROR;
break;
case SLEEP_NOT_NUMBER:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[SLEEP_NUMBER];
RetCode = MODULE_ERROR;
break;
case ODD_URL_PARAMETERS:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[URL_PARAMETERS];
RetCode = MODULE_ERROR;
break;
case ODD_POST_PARAMETERS:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[POST_PARAMETERS];
RetCode = MODULE_ERROR;
break;
}
}
}
else
{
setErrorMsg(duk_safe_to_string(JsContext, -1), true);
RetCode = DUKTAPE_ERROR;
}
}
else
{
bool SendRetVal;
if (duk_is_boolean(JsContext, -1) ) SendRetVal = duk_get_boolean(JsContext, -1);
else
{
setErrorMsg(ErrorMessages[NOT_BOOL], true);
SendRetVal = (bool) ( (int8_t) duk_to_number(JsContext, -1) );
}
if (!SendRetVal) RetCode = GATEWAY_ERROR;
}
httpCleanUp(Handle);
return RetCode;
}
bool Get( duk_context * ctx, const int index, const bool * )
{
dukbind_assert( duk_is_boolean( ctx, index ), "No conversion is allowed in Get methods" );
return duk_to_boolean( ctx, index );
}
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");
}
