static duk_ret_t test_is_prototype_of(duk_context *ctx, void *udata) {
(void) udata;
prep(ctx);
/* obj0.isPrototypeOf(dummy) -> false, traverses prototype chain of dummy */
duk_eval_string(ctx, "Object.prototype.isPrototypeOf");
duk_dup(ctx, 0);
duk_push_object(ctx);
duk_call_method(ctx, 1);
printf("Object.prototype.isPrototypeOf result: %s\n", duk_safe_to_string(ctx, -1));
duk_pop(ctx);
/* obj0.isPrototypeOf(obj1) -> true, traverses prototype chain of obj1 */
duk_eval_string(ctx, "Object.prototype.isPrototypeOf");
duk_dup(ctx, 0);
duk_dup(ctx, 1);
duk_call_method(ctx, 1);
printf("Object.prototype.isPrototypeOf result: %s\n", duk_safe_to_string(ctx, -1));
duk_pop(ctx);
/* dummy.isPrototypeOf(obj0) -> traverses prototype chain of obj0 and throws */
duk_eval_string(ctx, "Object.prototype.isPrototypeOf");
duk_push_object(ctx);
duk_dup(ctx, 0);
duk_call_method(ctx, 1);
printf("Object.prototype.isPrototypeOf result: %s\n", duk_safe_to_string(ctx, -1));
duk_pop(ctx);
return 0;
}
void
duk_push_sphere_bytearray(duk_context* ctx, bytearray_t* array)
{
duk_push_object(ctx);
duk_push_string(ctx, "bytearray"); duk_put_prop_string(ctx, -2, "\xFF" "sphere_type");
duk_push_pointer(ctx, array); duk_put_prop_string(ctx, -2, "\xFF" "ptr");
duk_push_c_function(ctx, js_ByteArray_finalize, DUK_VARARGS); duk_set_finalizer(ctx, -2);
duk_push_c_function(ctx, js_ByteArray_toString, DUK_VARARGS); duk_put_prop_string(ctx, -2, "toString");
duk_push_c_function(ctx, js_ByteArray_concat, DUK_VARARGS); duk_put_prop_string(ctx, -2, "concat");
duk_push_c_function(ctx, js_ByteArray_slice, DUK_VARARGS); duk_put_prop_string(ctx, -2, "slice");
duk_push_string(ctx, "length"); duk_push_int(ctx, array->size);
duk_def_prop(ctx, -3,
DUK_DEFPROP_HAVE_CONFIGURABLE | 0
| DUK_DEFPROP_HAVE_WRITABLE | 0
| DUK_DEFPROP_HAVE_VALUE);
// return proxy object so we can catch array accesses
duk_push_global_object(ctx);
duk_get_prop_string(ctx, -1, "Proxy");
duk_dup(ctx, -3);
duk_push_object(ctx);
duk_push_c_function(ctx, js_ByteArray_getProp, DUK_VARARGS); duk_put_prop_string(ctx, -2, "get");
duk_push_c_function(ctx, js_ByteArray_setProp, DUK_VARARGS); duk_put_prop_string(ctx, -2, "set");
duk_new(ctx, 2);
duk_remove(ctx, -2);
duk_remove(ctx, -2);
}
void Expose_Light(duk_context* ctx)
{
duk_push_object(ctx);
duk_put_function_list(ctx, -1, Light_StaticFunctions);
duk_push_number(ctx, 0);
duk_put_prop_string(ctx, -2, "PointLight");
duk_push_number(ctx, 1);
duk_put_prop_string(ctx, -2, "Spotlight");
duk_push_number(ctx, 2);
duk_put_prop_string(ctx, -2, "DirectionalLight");
duk_push_object(ctx);
duk_put_function_list(ctx, -1, Light_Functions);
DefineProperty(ctx, "ComponentNameChanged", Light_Get_ComponentNameChanged, nullptr);
DefineProperty(ctx, "ParentEntitySet", Light_Get_ParentEntitySet, nullptr);
DefineProperty(ctx, "ParentEntityAboutToBeDetached", Light_Get_ParentEntityAboutToBeDetached, nullptr);
DefineProperty(ctx, "typeName", Light_TypeName, nullptr);
DefineProperty(ctx, "typeId", Light_TypeId, nullptr);
DefineProperty(ctx, "name", Light_Name, Light_SetName_String);
DefineProperty(ctx, "replicated", Light_IsReplicated, Light_SetReplicated_bool);
DefineProperty(ctx, "local", Light_IsLocal, nullptr);
DefineProperty(ctx, "unacked", Light_IsUnacked, nullptr);
DefineProperty(ctx, "updateMode", Light_UpdateMode, Light_SetUpdateMode_AttributeChange__Type);
DefineProperty(ctx, "id", Light_Id, nullptr);
DefineProperty(ctx, "temporary", Light_IsTemporary, Light_SetTemporary_bool);
DefineProperty(ctx, "viewEnabled", Light_ViewEnabled, nullptr);
duk_put_prop_string(ctx, -2, "prototype");
duk_put_global_string(ctx, Light_ID);
}
static void duk__push_module_object(duk_context *ctx, const char *id, duk_bool_t main) {
duk_push_object(ctx);
/* Set this as the main module, if requested */
if (main) {
duk_push_global_stash(ctx);
duk_dup(ctx, -2);
duk_put_prop_string(ctx, -2, "\xff" "mainModule");
duk_pop(ctx);
}
/* Node.js uses the canonicalized filename of a module for both module.id
* and module.filename. We have no concept of a file system here, so just
* use the module ID for both values.
*/
duk_push_string(ctx, id);
duk_dup(ctx, -1);
duk_put_prop_string(ctx, -3, "filename");
duk_put_prop_string(ctx, -2, "id");
/* module.exports = {} */
duk_push_object(ctx);
duk_put_prop_string(ctx, -2, "exports");
/* module.loaded = false */
duk_push_false(ctx);
duk_put_prop_string(ctx, -2, "loaded");
/* module.require */
duk__push_require_function(ctx, id);
duk_put_prop_string(ctx, -2, "require");
}
DUK_EXTERNAL duk_ret_t sjs_mod_init(duk_context* ctx) {
duk_push_object(ctx);
duk_put_function_list(ctx, -1, module_funcs);
duk_push_object(ctx);
duk_put_number_list(ctx, -1, module_consts);
duk_put_prop_string(ctx, -2, "c");
return 1;
}
duk_ret_t dukopen_nsp_texture(duk_context *ctx) {
duk_idx_t idx = duk_push_object(ctx);
duk_idx_t stats_constr = duk_push_c_function(ctx, nsp_texture_constructor, DUK_VARARGS);
duk_idx_t stats_prot = duk_push_object(ctx);
duk_put_function_list(ctx, stats_prot, nsp_texture_methods);
duk_put_prop_string(ctx, stats_constr, "prototype");
duk_put_prop_string(ctx, idx, "Texture");
return 1;
}
static int init_binding_worker(duk_context *ctx) {
duk_push_global_stash(ctx);
duk_push_object(ctx);
duk_put_prop_string(ctx, -2, "comoWorkersCallBack");
duk_pop(ctx);
duk_push_object(ctx);
duk_put_function_list(ctx, -1, como_worker_funcs);
return 1;
}
duk_ret_t dukopen_logger(duk_context *ctx) noexcept
{
dukx_assert_begin(ctx);
duk_push_object(ctx);
duk_push_object(ctx);
duk_put_function_list(ctx, -1, loggerFunctions);
duk_put_prop_string(ctx, -2, "Logger");
dukx_assert_end(ctx, 1);
return 1;
}
int main(int argc, char *argv[]) {
int i, rc;
prg.argc = argc;
prg.argv = argv;
prg.name = argv[1];
duk_context *ctx = duk_create_heap_default();
duk_push_global_object(ctx);
duk_push_object(ctx); /* -> [ ... global obj ] */
sys1(ctx);
for(i=1;i<argc;i++) {
duk_push_string(ctx, argv[i]);
duk_put_prop_index(ctx, -2, i-1);
}
duk_push_number(ctx, argc-1);
duk_put_prop_string(ctx, -2, "argc");
duk_put_prop_string(ctx, -2, "Sys1"); /* -> [ ... global ] */
duk_push_object(ctx); /* -> [ ... global obj ] */
prg1(ctx);
duk_put_prop_string(ctx, -2, "Prg1"); /* -> [ ... global ] */
prg_push_modsearch(ctx);
duk_pop(ctx);
prg_parse_appfile(&prg);
// push file
duk_push_lstring(ctx, prg.main->buf, prg.main->size);
duk_push_string(ctx, argv[1]);
// execute file (compile + call)
prg_register(&prg);
rc = duk_safe_call(ctx, prg_wrapped_compile_execute, 2 /*nargs*/, 1 /*nret*/);
if (rc != DUK_EXEC_SUCCESS) {
print_error(ctx, stderr);
exit(2);
}
duk_pop(ctx); /* pop eval result */
duk_destroy_heap(ctx);
return prg.status;
}
StyleContext::StyleContext() {
m_ctx = duk_create_heap_default();
//// Create global geometry constants
// TODO make immutable
duk_push_number(m_ctx, GeometryType::points);
duk_put_global_string(m_ctx, "point");
duk_push_number(m_ctx, GeometryType::lines);
duk_put_global_string(m_ctx, "line");
duk_push_number(m_ctx, GeometryType::polygons);
duk_put_global_string(m_ctx, "polygon");
//// Create global 'feature' object
// Get Proxy constructor
// -> [cons]
duk_eval_string(m_ctx, "Proxy");
// Add feature object
// -> [cons, { __obj: this }]
duk_idx_t featureObj = duk_push_object(m_ctx);
duk_push_pointer(m_ctx, this);
duk_put_prop_string(m_ctx, featureObj, INSTANCE_ID);
// Add handler object
// -> [cons, {...}, { get: func, has: func }]
duk_idx_t handlerObj = duk_push_object(m_ctx);
// Add 'get' property to handler
duk_push_c_function(m_ctx, jsGetProperty, 3 /*nargs*/);
duk_put_prop_string(m_ctx, handlerObj, "get");
// Add 'has' property to handler
duk_push_c_function(m_ctx, jsHasProperty, 2 /*nargs*/);
duk_put_prop_string(m_ctx, handlerObj, "has");
// Call proxy constructor
// [cons, feature, handler ] -> [obj|error]
if (duk_pnew(m_ctx, 2) == 0) {
// put feature proxy object in global scope
if (!duk_put_global_string(m_ctx, "feature")) {
LOGE("Initialization failed");
}
} else {
LOGE("Failure: %s", duk_safe_to_string(m_ctx, -1));
duk_pop(m_ctx);
}
DUMP("init\n");
}
void Expose_IAssetTransfer(duk_context* ctx)
{
duk_push_object(ctx);
duk_push_object(ctx);
duk_put_function_list(ctx, -1, IAssetTransfer_Functions);
DefineProperty(ctx, "asset", IAssetTransfer_Get_asset, IAssetTransfer_Set_asset);
DefineProperty(ctx, "source", IAssetTransfer_Get_source, IAssetTransfer_Set_source);
DefineProperty(ctx, "assetType", IAssetTransfer_Get_assetType, IAssetTransfer_Set_assetType);
DefineProperty(ctx, "internalResourceName", IAssetTransfer_Get_internalResourceName, IAssetTransfer_Set_internalResourceName);
DefineProperty(ctx, "Downloaded", IAssetTransfer_Get_Downloaded, nullptr);
DefineProperty(ctx, "Succeeded", IAssetTransfer_Get_Succeeded, nullptr);
DefineProperty(ctx, "Failed", IAssetTransfer_Get_Failed, nullptr);
duk_put_prop_string(ctx, -2, "prototype");
duk_put_global_string(ctx, IAssetTransfer_ID);
}
duk_ret_t JsLibrarian::Constructor(duk_context* duktapeContext)
{
try {
if (duk_get_top(duktapeContext) != 0) JavaScriptHelper::Throw(duktapeContext, "No arguments for Librarian constructor expected");
if (duk_is_constructor_call(duktapeContext)) duk_push_this(duktapeContext);
else duk_push_object(duktapeContext);
duk_push_pointer(duktapeContext, new JsLibrarian);
duk_put_prop_string(duktapeContext, -2, "__Ptr");
duk_push_c_function(duktapeContext, JsLibrarian::Destructor, 1);
duk_set_finalizer(duktapeContext, -2);
duk_push_c_function(duktapeContext, JsLibrarian::Files, DUK_VARARGS);
duk_put_prop_string(duktapeContext, -2, "Files");
duk_push_c_function(duktapeContext, JsLibrarian::DependencyCheck, DUK_VARARGS);
duk_put_prop_string(duktapeContext, -2, "DependencyCheck");
duk_push_c_function(duktapeContext, JsLibrarian::Output, DUK_VARARGS);
duk_put_prop_string(duktapeContext, -2, "Output");
duk_push_c_function(duktapeContext, JsLibrarian::BeforeLink, DUK_VARARGS);
duk_put_prop_string(duktapeContext, -2, "BeforeLink");
duk_push_c_function(duktapeContext, JsLibrarian::Create, DUK_VARARGS);
duk_put_prop_string(duktapeContext, -2, "Create");
return 1;
}
catch (std::exception& e) {
JavaScriptHelper::Throw(duktapeContext, e.what());
}
}
static duk_ret_t test(duk_context *ctx) {
duk_push_object(ctx); /* [ ... obj ] */
duk_push_int(ctx, 42); /* [ ... obj 42 ] */
duk_put_prop_string(ctx, -2, "meaningOfLife"); /* [ ... obj ] */
/* compaction has no external impact */
duk_compact(ctx, -1); /* [ ... obj ] */
duk_dup_top(ctx);
printf("%s\n", duk_json_encode(ctx, -1));
duk_pop(ctx);
/* compaction doesn't prevent new properties from being added */
duk_push_string(ctx, "bar"); /* [ ... obj "bar" ] */
duk_put_prop_string(ctx, -2, "foo"); /* [ ... obj ] */
duk_dup_top(ctx);
printf("%s\n", duk_json_encode(ctx, -1));
duk_pop(ctx);
/* compaction can be done multiple times */
duk_compact(ctx, -1); /* [ ... obj ] */
duk_dup_top(ctx);
printf("%s\n", duk_json_encode(ctx, -1));
duk_pop(ctx);
return 0;
}
/*
* Returns information about this pin
*/
static int NativeInfoGetter(duk_context* ctx)
{
int idx;
uint32_t pin;
const AJS_IO_Info* info;
duk_push_this(ctx);
pin = GetPinId(ctx, -1, 0);
duk_pop(ctx);
info = AJS_TargetIO_GetInfo(pin);
if (!info) {
duk_error(ctx, DUK_ERR_INTERNAL_ERROR, "Undefined I/O pin%d", pin);
return 0;
}
duk_push_string(ctx, ", ");
idx = duk_push_object(ctx);
duk_push_int(ctx, info->physicalPin);
duk_put_prop_string(ctx, idx, "physicalPin");
duk_push_string(ctx, info->schematicId);
duk_put_prop_string(ctx, idx, "schematicId");
duk_push_string(ctx, info->datasheetId);
duk_put_prop_string(ctx, idx, "datasheetId");
duk_push_string(ctx, info->description);
duk_put_prop_string(ctx, idx, "description");
/*
* Return the object we just created
*/
return 1;
}
static duk_ret_t test_string(duk_context *ctx, void *udata) {
duk_idx_t i, n;
(void) udata;
duk_push_undefined(ctx);
duk_push_null(ctx);
duk_push_true(ctx);
duk_push_false(ctx);
duk_push_string(ctx, "");
duk_push_string(ctx, "foo");
duk_push_lstring(ctx, "foo\0bar", 7);
duk_push_string(ctx, "\xe1\x88\xb4xyz"); /* 4 chars, first char utf-8 encoded U+1234 */
duk_push_nan(ctx);
duk_push_object(ctx);
n = duk_get_top(ctx);
printf("top: %ld\n", (long) n);
for (i = 0; i <= n; i++) {
printf("index %ld: ", (long) i);
dump((const unsigned char *) duk_get_string_default(ctx, i, "default"));
}
return 0;
}
void
_gum_duk_create_subclass (duk_context * ctx,
const gchar * parent,
const gchar * name,
duk_c_function constructor,
gint constructor_nargs,
duk_c_function finalize)
{
duk_push_global_object (ctx);
duk_get_prop_string (ctx, -1, "Object");
duk_get_prop_string (ctx, -1, "create");
duk_get_prop_string (ctx, -3, parent);
duk_get_prop_string (ctx, -1, "prototype");
duk_dup (ctx, -3);
duk_dup (ctx, -2);
duk_call (ctx, 1);
if (constructor != NULL)
duk_push_c_function (ctx, constructor, constructor_nargs);
else
duk_push_object (ctx);
duk_dup (ctx, -2);
if (finalize != NULL)
{
duk_push_c_function (ctx, finalize, 2);
duk_set_finalizer (ctx, -2);
}
duk_put_prop_string (ctx, -2, "prototype");
duk_put_prop_string (ctx, -7, name);
duk_pop_n (ctx, 6);
}
static duk_ret_t test_1(duk_context *ctx, void *udata) {
duk_idx_t i, n;
(void) udata;
duk_set_top(ctx, 0);
duk_push_undefined(ctx);
duk_push_null(ctx);
duk_push_true(ctx);
duk_push_false(ctx);
duk_push_int(ctx, 0);
duk_push_int(ctx, 1);
duk_push_nan(ctx);
duk_push_number(ctx, INFINITY);
duk_push_string(ctx, "");
duk_push_string(ctx, "foo");
duk_push_object(ctx);
duk_push_thread(ctx);
duk_push_fixed_buffer(ctx, 0);
duk_push_fixed_buffer(ctx, 1024);
duk_push_dynamic_buffer(ctx, 0);
duk_push_dynamic_buffer(ctx, 1024);
duk_push_pointer(ctx, (void *) NULL);
duk_push_pointer(ctx, (void *) 0xdeadbeef);
n = duk_get_top(ctx);
printf("top: %ld\n", (long) n);
for (i = 0; i < n; i++) {
duk_to_null(ctx, i);
printf("index %ld, is-null: %d\n", (long) i, (int) duk_is_null(ctx, i));
}
return 0;
}
duk_ret_t duv_setup_request(duk_context *ctx, uv_req_t* req, int callback) {
// Create a new container object for the request with request methods
duk_push_object(ctx);
duk_push_heap_stash(ctx);
duk_get_prop_string(ctx, -1, "req-prototype");
duk_remove(ctx, -2);
duk_set_prototype(ctx, -2);
// Set buffer as uv-data internal property.
duk_insert(ctx, -2);
duk_put_prop_string(ctx, -2, "\xff""uv-data");
// Store the request type.
duk_push_int(ctx, req->type);
duk_put_prop_string(ctx, -2, "\xff""req-type");
// Store a reference to the lua callback
duk_dup(ctx, callback);
duk_put_prop_string(ctx, -2, "\xff""uv-callback");
// Store this object in the heap stack keyed by the request's pointer address.
// This will prevent it from being garbage collected and allow us to find
// it with nothing more than the request's address.
duv_store_handle(ctx, req);
// Store the context in the handle so it can use duktape APIs.
req->data = ctx;
// TODO: is this still on the stack?
return 1;
}
static duk_ret_t test_2a(duk_context *ctx, void *udata) {
(void) udata;
/* Test first with nothing on stack index -3. */
duk_safe_call(ctx, test__null, NULL, 0, 1); printf("%s\n", duk_safe_to_string(ctx, 0));
duk_pop(ctx);
duk_set_top(ctx, 0); duk_push_undefined(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_null(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_true(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_false(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_number(ctx, 123.0); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_string(ctx, "foo\x00" "bar"); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_fixed_buffer(ctx, 16); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_pointer(ctx, NULL); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_pointer(ctx, (void *) 0xdeadbeefUL); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_object(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_array(ctx); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_c_function(ctx, dummy_func, 0); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_c_lightfunc(ctx, dummy_func, 0, 0, 0); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_eval_string(ctx, "(function dummy(){})"); test__require_calls(ctx);
duk_set_top(ctx, 0); duk_push_thread(ctx); test__require_calls(ctx);
printf("done\n");
return 0;
}
void duk_push_java_object(duk_context *ctx, JNIEnv *env, jobject object){
if(object == NULL){
duk_push_null(ctx);
return;
}
if((*env)->IsInstanceOf(env, object, js_ref_class)){
jint ref = (*env)->CallIntMethod(env, object, js_ref_get_ref_method);
duk_push_js_ref(ctx, ref);
return;
}
if((*env)->IsInstanceOf(env, object, java_number_class)){
jdouble num = (*env)->CallDoubleMethod(env, object, java_number_get_double_value_method);
duk_push_global_object(ctx);
duk_get_prop_string(ctx, -1, "Number");
duk_push_number(ctx, num);
duk_new(ctx, 1);
duk_mark_jsobject_to_java_object(ctx, -1, env, object);
duk_remove(ctx, -2);
return;
}
if((*env)->IsInstanceOf(env, object, java_boolean_class)){
jboolean value = (*env)->CallBooleanMethod(env, object, java_boolean_get_boolean_value_method);
if(value){
duk_push_true(ctx);
}else{
duk_push_false(ctx);
}
return;
}
duk_push_object(ctx); //empty target
duk_mark_jsobject_to_java_object(ctx, -1, env, object);
}
static duk_ret_t test_1(duk_context *ctx, void *udata) {
(void) udata;
duk_eval_string(ctx, "(function (x) { print(Duktape.enc('jx', x)); })");
duk_push_object(ctx);
/* Ordinary property */
duk_push_int(ctx, 1);
duk_put_prop_string(ctx, -2, "foo"); /* obj.foo = 1 */
/* Internal property \xFF\xFFabc, technically enumerable (based on
* property attributes) but because of internal property special
* behavior, does not enumerate.
*/
duk_push_int(ctx, 2);
duk_put_prop_string(ctx, -2, "\xff\xff" "abc"); /* obj[\xff\xffabc] = 2, internal property */
/* Another property with invalid UTF-8 data but doesn't begin with
* \xFF => gets enumerated and JX prints out an approximate key.
*/
duk_push_int(ctx, 3);
duk_put_prop_string(ctx, -2, " \xff" "bar"); /* obj[ \xffbar] = 3, invalid utf-8 but not an internal property */
duk_call(ctx, 1);
printf("final top: %ld\n", (long) duk_get_top(ctx));
return 0;
}
int duk_import_java_class(duk_context *ctx){
DEBUG_LOG("DuktapeEngine", "className duk_import_java_class");
int n = duk_get_top(ctx);
const char* className = duk_to_string(ctx, 0);
const char* shortName = NULL;
if(n > 1){
shortName = duk_to_string(ctx, 1);
}else{
shortName = strrchr(className, '.');
shortName++;
}
DEBUG_LOG("DuktapeEngine", "className %s shorName %s",className, shortName);
duk_push_global_object(ctx);
duk_push_c_function(ctx, duk_new_java_class, DUK_VARARGS);
JNIEnv *env = get_java_jni_env();
jstring fullClassName = (*env)->NewStringUTF(env, className);
jobject value = (*env)->CallStaticObjectMethod(env, java_api_class, java_import_class_method, fullClassName);
duk_mark_jsobject_to_java_object(ctx, -1, env, value);
(*env)->DeleteLocalRef(env, value);
(*env)->DeleteLocalRef(env, fullClassName);
duk_push_object(ctx);
duk_push_string(ctx, className);
duk_put_prop_string(ctx, -2, "className");
duk_put_prop_string(ctx, -2, "prototype");
duk_put_prop_string(ctx, -2, shortName);
duk_pop(ctx);
return 0;
}
void
_gum_duk_push_proxy (duk_context * ctx,
duk_idx_t target,
duk_c_function getter,
duk_c_function setter)
{
duk_dup (ctx, target);
duk_get_global_string (ctx, "Proxy");
duk_dup (ctx, -2);
duk_push_object (ctx);
if (getter != NULL)
{
duk_push_c_function (ctx, getter, 3);
duk_put_prop_string (ctx, -2, "get");
}
if (setter != NULL)
{
duk_push_c_function (ctx, setter, 4);
duk_put_prop_string (ctx, -2, "set");
}
duk_new (ctx, 2);
duk_swap_top (ctx, -2);
duk_pop (ctx);
}
duk_ret_t
mn_bi_cluster(duk_context *ctx) {
duk_push_object(ctx);
duk_put_function_list(ctx, -1, mn_bi_cluster_funcs);
duk_put_number_list(ctx, -1, mn_bi_cluster_consts);
return 1;
}
/*
* An AllJoyn dictionary entry maps cleanly to a JavaScript object property
*/
static AJ_Status PushDictionaryArg(duk_context* ctx, AJ_Message* msg)
{
AJ_Arg arg;
AJ_Status status = AJ_UnmarshalContainer(msg, &arg, AJ_ARG_ARRAY);
if (status == AJ_OK) {
int objIndex = duk_push_object(ctx);
while (status == AJ_OK) {
AJ_Arg entry;
status = AJ_UnmarshalContainer(msg, &entry, AJ_ARG_DICT_ENTRY);
if (status == AJ_OK) {
status = PushArg(ctx, msg); // key
if (status == AJ_OK) {
status = PushArg(ctx, msg); // value
}
if (status == AJ_OK) {
duk_put_prop(ctx, objIndex);
}
AJ_UnmarshalCloseContainer(msg, &entry);
}
}
if (status == AJ_ERR_NO_MORE) {
status = AJ_OK;
}
AJ_UnmarshalCloseContainer(msg, &arg);
}
return status;
}
static int Material_GetShaderParameters(duk_context* ctx)
{
duk_push_this(ctx);
Material* material = js_to_class_instance<Material>(ctx, -1, 0);
const HashMap<StringHash, MaterialShaderParameter>& params = material->GetShaderParameters();
duk_push_array(ctx);
unsigned j = 0;
for (HashMap<StringHash, MaterialShaderParameter>::ConstIterator i = params.Begin(); i != params.End(); ++i)
{
duk_push_object(ctx);
duk_push_string(ctx, i->second_.name_.CString());
duk_put_prop_string(ctx, -2, "name");
js_push_variant(ctx, i->second_.value_);
duk_put_prop_string(ctx, -2, "value");
duk_push_string(ctx, i->second_.value_.ToString().CString());
duk_put_prop_string(ctx, -2, "valueString");
duk_push_string(ctx, i->second_.value_.GetTypeName().CString());
duk_put_prop_string(ctx, -2, "typeName");
duk_push_number(ctx, (double) i->second_.value_.GetType());
duk_put_prop_string(ctx, -2, "type");
duk_put_prop_index(ctx, -2, j++);
}
return 1;
}
static duk_ret_t test_lstring(duk_context *ctx, void *udata) {
duk_idx_t i, n;
(void) udata;
duk_push_undefined(ctx);
duk_push_null(ctx);
duk_push_true(ctx);
duk_push_false(ctx);
duk_push_string(ctx, "");
duk_push_string(ctx, "foo");
duk_push_lstring(ctx, "foo\0bar", 7);
duk_push_string(ctx, "\xe1\x88\xb4xyz"); /* 4 chars, first char utf-8 encoded U+1234 */
duk_push_nan(ctx);
duk_push_object(ctx);
n = duk_get_top(ctx);
printf("top: %ld\n", (long) n);
for (i = 0; i < n; i++) {
const char *buf;
size_t len;
len = (size_t) 0xdeadbeefUL;
buf = duk_get_lstring_default(ctx, i, &len, "default!", 7);
printf("index %ld: length %lu: ",
(long) i, (unsigned long) len);
dump((const unsigned char *) buf);
buf = duk_get_lstring_default(ctx, i, NULL, "default!", 7);
printf("index %ld: ", (long) i);
dump((const unsigned char *) buf);
}
return 0;
}
static void duk_push_rayqueryresult(duk_context* ctx, const RayQueryResult& result)
{
duk_push_object(ctx);
duk_push_new_vector3(ctx, result.position_);
duk_put_prop_string(ctx, -2, "position");
duk_push_new_vector3(ctx, result.normal_);
duk_put_prop_string(ctx, -2, "normal");
duk_push_new_vector2(ctx, result.textureUV_);
duk_put_prop_string(ctx, -2, "textureUV");
duk_push_number(ctx, result.distance_);
duk_put_prop_string(ctx, -2, "distance");
js_push_class_object_instance(ctx, result.drawable_, "Drawable");
duk_put_prop_string(ctx, -2, "drawable");
js_push_class_object_instance(ctx, result.node_, "Node");
duk_put_prop_string(ctx, -2, "node");
duk_push_number(ctx, (duk_double_t) result.subObject_);
duk_put_prop_string(ctx, -2, "subObject");
}
int test_1(duk_context *ctx) {
int i, n;
duk_set_top(ctx, 0);
duk_push_true(ctx);
duk_push_false(ctx);
duk_push_int(ctx, 0);
duk_push_int(ctx, 1);
duk_push_nan(ctx);
duk_push_number(ctx, INFINITY);
duk_push_string(ctx, "");
duk_push_string(ctx, "foo");
duk_push_object(ctx);
duk_push_thread(ctx);
n = duk_get_top(ctx);
printf("top: %d\n", n);
for (i = 0; i < n; i++) {
int t;
duk_to_object(ctx, i);
t = duk_get_type(ctx, i);
duk_to_string(ctx, i);
printf("index %d, type: %d, string coerced: %s\n", i, t, duk_to_string(ctx, i));
}
return 0;
}
static Box * PrivatePush( duk_context * ctx, const size_t class_index, const size_t object_size, finalizer_t finalizer )
{
duk_push_global_object( ctx );
duk_get_prop_string( ctx, -1, "Proxy" );
duk_remove( ctx, -2 );
duk_push_object( ctx );
size_t require_size = sizeof( Box ) + object_size;
Box * box = reinterpret_cast<Box*>( duk_push_fixed_buffer( ctx, require_size ) );
box->ClassIndex = class_index;
box->Finalizer = finalizer;
duk_put_prop_string( ctx, -2, "\xFF" "Box" );
duk_push_c_function( ctx, &internal::ClassFinalizer, 1 );
duk_set_finalizer( ctx, -2 );
duk_push_heap_stash( ctx );
duk_get_prop_string( ctx, -1, "InstanceHandler" );
duk_remove( ctx, -2 );
duk_new( ctx, 2 );
return box;
}
