static duk_ret_t duk_btnp(duk_context* duk)
{
tic_machine* machine = getDukMachine(duk);
tic_mem* memory = (tic_mem*)machine;
if (duk_is_null_or_undefined(duk, 0))
{
duk_push_uint(duk, memory->api.btnp(memory, -1, -1, -1));
}
else if(duk_is_null_or_undefined(duk, 1) && duk_is_null_or_undefined(duk, 2))
{
s32 index = duk_to_int(duk, 0) & 0x1f;
duk_push_boolean(duk, memory->api.btnp(memory, index, -1, -1));
}
else
{
s32 index = duk_to_int(duk, 0) & 0x1f;
u32 hold = duk_to_int(duk, 1);
u32 period = duk_to_int(duk, 2);
duk_push_boolean(duk, memory->api.btnp(memory, index, hold, period));
}
return 1;
}
static s32 duk_keyp(duk_context* duk)
{
tic_machine* machine = getDukMachine(duk);
tic_mem* tic = &machine->memory;
if (duk_is_null_or_undefined(duk, 0))
{
duk_push_boolean(duk, tic->api.keyp(tic, tic_key_unknown, -1, -1));
}
else
{
tic_key key = duk_to_int(duk, 0);
if(key >= tic_key_escape)
{
return duk_error(duk, DUK_ERR_ERROR, "unknown keyboard code\n");
}
else
{
if(duk_is_null_or_undefined(duk, 1) && duk_is_null_or_undefined(duk, 2))
{
duk_push_boolean(duk, tic->api.keyp(tic, key, -1, -1));
}
else
{
u32 hold = duk_to_int(duk, 1);
u32 period = duk_to_int(duk, 2);
duk_push_boolean(duk, tic->api.keyp(tic, key, hold, period));
}
}
}
return 1;
}
static int Serializer_Write(duk_context* ctx)
{
duk_int_t magic = duk_get_current_magic(ctx);
duk_push_this(ctx);
// safe cast based on type check above
Serializer* serial = CastToSerializer(ctx, duk_get_top_index(ctx));
duk_pop(ctx);
if (!serial)
{
duk_push_boolean(ctx, 0);
return 1;
}
const char* str;
size_t length;
IO_MAGIC_TYPE v = (IO_MAGIC_TYPE) magic;
bool success = false;
switch(v)
{
case IO_MAGIC_INT:
success = serial->WriteInt((int) duk_require_number(ctx, 0));
break;
case IO_MAGIC_STRING:
str = duk_require_string(ctx, 0);
length = strlen(str);
success = serial->Write(str, length);
/*
if (length)
{
buffer.Resize(length);
for (size_t i = 0; i < length; i++)
buffer[i] = str[i];
serial->WriteBuffer(buffer);
}
*/
break;
case IO_MAGIC_ZEROSTRING:
success = serial->WriteString(duk_require_string(ctx, 0));
break;
default:
break;
}
duk_push_boolean(ctx, success ? 1 : 0);
return 1;
}
duk_idx_t AJS_UnmarshalMessage(duk_context* ctx, AJ_Message* msg, uint8_t accessor)
{
duk_idx_t objIndex = duk_push_object(ctx);
duk_push_string(ctx, msg->sender);
duk_put_prop_string(ctx, objIndex, "sender");
if ((msg->hdr->msgType == AJ_MSG_METHOD_CALL) || (msg->hdr->msgType == AJ_MSG_SIGNAL)) {
duk_push_string(ctx, msg->member);
duk_put_prop_string(ctx, objIndex, "member");
duk_push_string(ctx, msg->iface);
duk_put_prop_string(ctx, objIndex, "iface");
duk_push_string(ctx, msg->objPath);
duk_put_prop_string(ctx, objIndex, "path");
/* If sender == unique name then true, otherwise false */
duk_push_boolean(ctx, !abs(strcmp(msg->sender, AJS_GetBusAttachment()->uniqueName)));
duk_put_prop_string(ctx, objIndex, "fromSelf");
if (msg->hdr->msgType == AJ_MSG_METHOD_CALL) {
AJS_ReplyInternal* msgReply;
/*
* Private read-only information needed for composing the reply
*/
duk_push_string(ctx, AJS_HIDDEN_PROP("reply"));
msgReply = duk_push_fixed_buffer(ctx, sizeof(AJS_ReplyInternal));
msgReply->msgId = msg->msgId;
msgReply->flags = msg->hdr->flags;
msgReply->serialNum = msg->hdr->serialNum;
msgReply->sessionId = msg->sessionId;
msgReply->accessor = accessor;
duk_def_prop(ctx, objIndex, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_HAVE_WRITABLE);
/*
* Register the reply functions
*/
duk_push_c_lightfunc(ctx, AJS_MethodCallReply, DUK_VARARGS, 0, 0);
duk_put_prop_string(ctx, objIndex, "reply");
duk_push_c_lightfunc(ctx, AJS_MethodCallError, DUK_VARARGS, 0, 0);
duk_put_prop_string(ctx, objIndex, "errorReply");
}
} else {
int isError = (msg->hdr->msgType == AJ_MSG_ERROR);
AJ_InfoPrintf(("Reply serial %d\n", msg->replySerial));
duk_push_int(ctx, msg->replySerial);
duk_put_prop_string(ctx, objIndex, "replySerial");
if (isError) {
duk_push_string(ctx, msg->error);
duk_put_prop_string(ctx, objIndex, "error");
}
duk_push_boolean(ctx, isError);
duk_put_prop_string(ctx, objIndex, "isErrorReply");
}
return objIndex;
}
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");
}
}
DUK_INTERNAL void duk_regexp_create_instance(duk_hthread *thr) {
duk_context *ctx = (duk_context *) thr;
duk_hobject *h;
duk_hstring *h_bc;
duk_small_int_t re_flags;
/* [ ... escape_source bytecode ] */
h_bc = duk_get_hstring(ctx, -1);
DUK_ASSERT(h_bc != NULL);
DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(h_bc) >= 1); /* always at least the header */
DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h_bc) >= 1);
DUK_ASSERT((duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0] < 0x80); /* flags always encodes to 1 byte */
re_flags = (duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0];
/* [ ... escaped_source bytecode ] */
duk_push_object(ctx);
h = duk_get_hobject(ctx, -1);
DUK_ASSERT(h != NULL);
duk_insert(ctx, -3);
/* [ ... regexp_object escaped_source bytecode ] */
DUK_HOBJECT_SET_CLASS_NUMBER(h, DUK_HOBJECT_CLASS_REGEXP);
DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[DUK_BIDX_REGEXP_PROTOTYPE]);
duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_BYTECODE, DUK_PROPDESC_FLAGS_NONE);
/* [ ... regexp_object escaped_source ] */
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_SOURCE, DUK_PROPDESC_FLAGS_NONE);
/* [ ... regexp_object ] */
duk_push_boolean(ctx, (re_flags & DUK_RE_FLAG_GLOBAL));
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_GLOBAL, DUK_PROPDESC_FLAGS_NONE);
duk_push_boolean(ctx, (re_flags & DUK_RE_FLAG_IGNORE_CASE));
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_IGNORE_CASE, DUK_PROPDESC_FLAGS_NONE);
duk_push_boolean(ctx, (re_flags & DUK_RE_FLAG_MULTILINE));
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MULTILINE, DUK_PROPDESC_FLAGS_NONE);
duk_push_int(ctx, 0);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LAST_INDEX, DUK_PROPDESC_FLAGS_W);
/* [ ... regexp_object ] */
}
static duk_ret_t IAssetStorage_Trusted(duk_context* ctx)
{
IAssetStorage* thisObj = GetThisWeakObject<IAssetStorage>(ctx);
bool ret = thisObj->Trusted();
duk_push_boolean(ctx, ret);
return 1;
}
DUK_LOCAL duk_ret_t duk__finalize_helper(duk_context *ctx, void *udata) {
duk_hthread *thr;
DUK_ASSERT(ctx != NULL);
thr = (duk_hthread *) ctx;
DUK_UNREF(udata);
DUK_DDD(DUK_DDDPRINT("protected finalization helper running"));
/* [... obj] */
/* XXX: Finalizer lookup should traverse the prototype chain (to allow
* inherited finalizers) but should not invoke accessors or proxy object
* behavior. At the moment this lookup will invoke proxy behavior, so
* caller must ensure that this function is not called if the target is
* a Proxy.
*/
duk_get_prop_stridx_short(ctx, -1, DUK_STRIDX_INT_FINALIZER); /* -> [... obj finalizer] */
if (!duk_is_callable(ctx, -1)) {
DUK_DDD(DUK_DDDPRINT("-> no finalizer or finalizer not callable"));
return 0;
}
duk_dup_m2(ctx);
duk_push_boolean(ctx, DUK_HEAP_HAS_FINALIZER_NORESCUE(thr->heap));
DUK_DDD(DUK_DDDPRINT("-> finalizer found, calling finalizer"));
duk_call(ctx, 2); /* [ ... obj finalizer obj heapDestruct ] -> [ ... obj retval ] */
DUK_DDD(DUK_DDDPRINT("finalizer finished successfully"));
return 0;
/* Note: we rely on duk_safe_call() to fix up the stack for the caller,
* so we don't need to pop stuff here. There is no return value;
* caller determines rescued status based on object refcount.
*/
}
// Constructor of the JS Object
duk_ret_t js_myPlugin_ctor(duk_context *ctx)
{
slog(DEBUG,DEBUG, "Creating new object of "PLUGIN_SCOPE);
myPluginStructure *mps = malloc(sizeof(myPluginStructure));
mps->name = duk_require_string(ctx, 0);
// Push special this binding to the function being constructed
duk_push_this(ctx);
// Store the underlying object
duk_push_pointer(ctx, mps);
duk_put_prop_string(ctx, -2, "\xff""\xff""data");
// TODO : - if not existand create a hash_map
// - store structure to a hash_map('name');
// so that it can be reached from JS and C
// Store a boolean flag to mark the object as deleted because the destructor may be called several times
duk_push_boolean(ctx, false);
duk_put_prop_string(ctx, -2, "\xff""\xff""deleted");
// Store the function destructor
duk_push_c_function(ctx, js_myPlugin_dtor, 1);
duk_set_finalizer(ctx, -2);
return 0;
}
static duk_ret_t Avatar_IsTemporary(duk_context* ctx)
{
Avatar* thisObj = GetThisWeakObject<Avatar>(ctx);
bool ret = thisObj->IsTemporary();
duk_push_boolean(ctx, ret);
return 1;
}
DUK_INTERNAL duk_ret_t duk_bi_array_constructor_is_array(duk_context *ctx) {
duk_hobject *h;
h = duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_ARRAY);
duk_push_boolean(ctx, (h != NULL));
return 1;
}
static duk_ret_t Terrain_AllPatchesLoaded(duk_context* ctx)
{
Terrain* thisObj = GetThisWeakObject<Terrain>(ctx);
bool ret = thisObj->AllPatchesLoaded();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t IAssetStorage_HasLiveUpdate(duk_context* ctx)
{
IAssetStorage* thisObj = GetThisWeakObject<IAssetStorage>(ctx);
bool ret = thisObj->HasLiveUpdate();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t dukky_html_table_cell_element_noWrap_getter(duk_context *ctx)
{
/* Get private data for method */
html_table_cell_element_private_t *priv = NULL;
duk_push_this(ctx);
duk_get_prop_string(ctx, -1, dukky_magic_string_private);
priv = duk_get_pointer(ctx, -1);
duk_pop_2(ctx);
if (priv == NULL) {
return 0; /* can do? No can do. */
}
#line 31 "HTMLTableCellElement.bnd"
dom_exception exc;
bool b;
exc = dom_html_table_cell_element_get_no_wrap((struct dom_html_table_cell_element *)((node_private_t*)priv)->node, &b);
if (exc != DOM_NO_ERR) {
return 0;
}
duk_push_boolean(ctx, b);
return 1;
}
static duk_ret_t PhysicsWorld_IsDebugGeometryEnabled(duk_context* ctx)
{
PhysicsWorld* thisObj = GetThisWeakObject<PhysicsWorld>(ctx);
bool ret = thisObj->IsDebugGeometryEnabled();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t IAssetTransfer_CachingAllowed(duk_context* ctx)
{
IAssetTransfer* thisObj = GetThisWeakObject<IAssetTransfer>(ctx);
bool ret = thisObj->CachingAllowed();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t IAssetTransfer_Abort(duk_context* ctx)
{
IAssetTransfer* thisObj = GetThisWeakObject<IAssetTransfer>(ctx);
bool ret = thisObj->Abort();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t Avatar_ViewEnabled(duk_context* ctx)
{
Avatar* thisObj = GetThisWeakObject<Avatar>(ctx);
bool ret = thisObj->ViewEnabled();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t Line_IsFinite(duk_context* ctx)
{
Line* thisObj = GetThisValueObject<Line>(ctx, Line_ID);
bool ret = thisObj->IsFinite();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t Terrain_IsTemporary(duk_context* ctx)
{
Terrain* thisObj = GetThisWeakObject<Terrain>(ctx);
bool ret = thisObj->IsTemporary();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t IAssetStorage_AutoDiscoverable(duk_context* ctx)
{
IAssetStorage* thisObj = GetThisWeakObject<IAssetStorage>(ctx);
bool ret = thisObj->AutoDiscoverable();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t IAsset_LoadFromCache(duk_context* ctx)
{
IAsset* thisObj = GetThisWeakObject<IAsset>(ctx);
bool ret = thisObj->LoadFromCache();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t PhysicsWorld_IsClient(duk_context* ctx)
{
PhysicsWorld* thisObj = GetThisWeakObject<PhysicsWorld>(ctx);
bool ret = thisObj->IsClient();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t Avatar_SupportsDynamicAttributes(duk_context* ctx)
{
Avatar* thisObj = GetThisWeakObject<Avatar>(ctx);
bool ret = thisObj->SupportsDynamicAttributes();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t Terrain_SupportsDynamicAttributes(duk_context* ctx)
{
Terrain* thisObj = GetThisWeakObject<Terrain>(ctx);
bool ret = thisObj->SupportsDynamicAttributes();
duk_push_boolean(ctx, ret);
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);
}
static duk_ret_t Terrain_ViewEnabled(duk_context* ctx)
{
Terrain* thisObj = GetThisWeakObject<Terrain>(ctx);
bool ret = thisObj->ViewEnabled();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t AssetReferenceList_IsEmpty(duk_context* ctx)
{
AssetReferenceList* thisObj = GetThisValueObject<AssetReferenceList>(ctx, AssetReferenceList_ID);
bool ret = thisObj->IsEmpty();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t IAsset_IsModified(duk_context* ctx)
{
IAsset* thisObj = GetThisWeakObject<IAsset>(ctx);
bool ret = thisObj->IsModified();
duk_push_boolean(ctx, ret);
return 1;
}
static duk_ret_t EntityReference_IsEmpty(duk_context* ctx)
{
EntityReference* thisObj = GetThisValueObject<EntityReference>(ctx, EntityReference_ID);
bool ret = thisObj->IsEmpty();
duk_push_boolean(ctx, ret);
return 1;
}
