static duk_ret_t test_2a(duk_context *ctx, void *udata) { (void) udata; /* Test first with nothing on stack index -3. */ duk_safe_call(ctx, test__null, NULL, 0, 1); printf("%s\n", duk_safe_to_string(ctx, 0)); duk_pop(ctx); duk_set_top(ctx, 0); duk_push_undefined(ctx); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_null(ctx); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_true(ctx); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_false(ctx); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_number(ctx, 123.0); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_string(ctx, "foo\x00" "bar"); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_fixed_buffer(ctx, 16); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_pointer(ctx, NULL); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_pointer(ctx, (void *) 0xdeadbeefUL); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_object(ctx); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_array(ctx); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_c_function(ctx, dummy_func, 0); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_c_lightfunc(ctx, dummy_func, 0, 0, 0); test__require_calls(ctx); duk_set_top(ctx, 0); duk_eval_string(ctx, "(function dummy(){})"); test__require_calls(ctx); duk_set_top(ctx, 0); duk_push_thread(ctx); test__require_calls(ctx); printf("done\n"); return 0; }
static duk_ret_t test_1(duk_context *ctx) { duk_size_t i, n; char *buf; duk_set_top(ctx, 0); duk_push_undefined(ctx); duk_push_null(ctx); duk_push_true(ctx); duk_push_false(ctx); duk_push_nan(ctx); duk_push_number(ctx, -INFINITY); duk_push_number(ctx, +INFINITY); duk_push_number(ctx, -0.0); duk_push_number(ctx, +0.0); duk_push_int(ctx, 123); duk_push_string(ctx, "foo"); duk_push_lstring(ctx, "foo\0bar", 7); /* internal NULs are kept */ duk_push_object(ctx); buf = (char *) duk_push_fixed_buffer(ctx, 0); buf = (char *) duk_push_fixed_buffer(ctx, 16); for (i = 0; i < 16; i++) { buf[i] = i; } buf = (char *) duk_push_dynamic_buffer(ctx, 0); buf = (char *) duk_push_dynamic_buffer(ctx, 16); for (i = 0; i < 16; i++) { buf[i] = i; } 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_int_t t1, t2; void *ptr; duk_size_t sz; duk_dup(ctx, i); t1 = duk_get_type(ctx, -1); sz = (duk_size_t) 0xdeadbeef; ptr = duk_to_buffer(ctx, -1, &sz); t2 = duk_get_type(ctx, -1); printf("index %ld, type %ld -> %ld, ptr-is-NULL %d, size %lu\n", (long) i, (long) t1, (long) t2, (sz == 0 ? -1 : (ptr == NULL ? 1 : 0)), (unsigned long) sz); dump_buffer(ctx); duk_pop(ctx); /* just check that this doesn't break */ duk_dup(ctx, i); ptr = duk_to_buffer(ctx, -1, NULL); duk_pop(ctx); } return 0; }
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; }
/* Shared helper to implement Object.getPrototypeOf and the ES6 * Object.prototype.__proto__ getter. * * https://people.mozilla.org/~jorendorff/es6-draft.html#sec-get-object.prototype.__proto__ */ duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx) { duk_hobject *h; /* magic: 0=getter call, 1=Object.getPrototypeOf */ if (duk_get_current_magic(ctx) == 0) { duk_push_this_coercible_to_object(ctx); duk_insert(ctx, 0); } h = duk_require_hobject(ctx, 0); DUK_ASSERT(h != NULL); /* XXX: should the API call handle this directly, i.e. attempt * to duk_push_hobject(ctx, null) would push a null instead? * (On the other hand 'undefined' would be just as logical, but * not wanted here.) */ if (h->prototype) { duk_push_hobject(ctx, h->prototype); } else { duk_push_null(ctx); } return 1; }
void test(duk_context *ctx) { int i, n; duk_push_c_function(ctx, func, 0); duk_push_undefined(ctx); duk_push_null(ctx); duk_push_true(ctx); duk_push_false(ctx); duk_push_number(ctx, 123.456); duk_push_string(ctx, "foo"); duk_push_object(ctx); duk_push_array(ctx); duk_push_fixed_buffer(ctx, 16); duk_push_pointer(ctx, (void *) 0xdeadbeef); n = duk_get_top(ctx); printf("top: %d\n", n); for (i = 1; i < n; i++) { duk_dup(ctx, 0); duk_dup(ctx, i); duk_call_method(ctx, 0); /* [ ... func this ] -> [ ret ] */ duk_pop(ctx); } }
static duk_ret_t test_basic(duk_context *ctx, void *udata) { duk_idx_t i, n; duk_int_t rc; (void) udata; duk_push_undefined(ctx); duk_push_null(ctx); duk_push_true(ctx); duk_push_false(ctx); duk_push_string(ctx, "foo"); duk_push_int(ctx, 123); duk_push_object(ctx); duk_push_pointer(ctx, (void *) NULL); duk_push_pointer(ctx, (void *) 0xdeadbeefUL); n = duk_get_top(ctx); printf("top: %ld\n", (long) n); for (i = 0; i <= n; i++) { rc = duk_safe_call(ctx, safe_helper, (void *) i, 0, 1); if (rc != DUK_EXEC_SUCCESS) { printf("index %ld: %s\n", (long) i, duk_safe_to_string(ctx, -1)); } duk_pop(ctx); } printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
void test(duk_context *ctx) { duk_idx_t i, n; duk_push_undefined(ctx); duk_push_null(ctx); duk_push_true(ctx); duk_push_false(ctx); duk_push_string(ctx, "foo"); duk_push_string(ctx, "123"); duk_push_number(ctx, -INFINITY); duk_push_number(ctx, -123456789.0); duk_push_number(ctx, -0.0); duk_push_number(ctx, +0.0); duk_push_number(ctx, +123456789.0); duk_push_number(ctx, +INFINITY); 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++) { double d = duk_get_number(ctx, i); int c = fpclassify(d); printf("index %ld: number %lf, FP_NAN=%d, FP_INFINITE=%d, FP_ZERO=%d, FP_SUBNORMAL=%d, FP_NORMAL=%d, signbit=%d\n", (long) i, d, (c == FP_NAN ? 1 : 0), (c == FP_INFINITE ? 1 : 0), (c == FP_ZERO ? 1 : 0), (c == FP_SUBNORMAL ? 1 : 0), (c == FP_NORMAL ? 1 : 0), (signbit(d) ? 1 : 0)); } }
static void ctx_push_ruby_object(struct state *state, VALUE obj) { duk_context *ctx = state->ctx; duk_idx_t arr_idx; VALUE str; switch (TYPE(obj)) { case T_FIXNUM: duk_push_int(ctx, NUM2INT(obj)); return; case T_FLOAT: duk_push_number(ctx, NUM2DBL(obj)); return; case T_SYMBOL: #ifdef HAVE_RB_SYM2STR obj = rb_sym2str(obj); #else obj = rb_id2str(SYM2ID(obj)); #endif // Intentional fall-through: case T_STRING: str = encode_cesu8(state, obj); duk_push_lstring(ctx, RSTRING_PTR(str), RSTRING_LEN(str)); return; case T_TRUE: duk_push_true(ctx); return; case T_FALSE: duk_push_false(ctx); return; case T_NIL: duk_push_null(ctx); return; case T_ARRAY: arr_idx = duk_push_array(ctx); for (int idx = 0; idx < RARRAY_LEN(obj); idx++) { ctx_push_ruby_object(state, rb_ary_entry(obj, idx)); duk_put_prop_index(ctx, arr_idx, idx); } return; case T_HASH: duk_push_object(ctx); rb_hash_foreach(obj, ctx_push_hash_element, (VALUE)state); return; default: // Cannot convert break; } clean_raise(ctx, rb_eTypeError, "cannot convert %s", rb_obj_classname(obj)); }
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; }
void test(duk_context *ctx) { duk_idx_t i, n; 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_int(ctx, 123); duk_push_object(ctx); duk_push_fixed_buffer(ctx, 0); duk_push_fixed_buffer(ctx, 1024); duk_push_dynamic_buffer(ctx, 0); duk_push_dynamic_buffer(ctx, 2048); n = duk_get_top(ctx); printf("top: %ld\n", (long) n); for (i = 0; i < n; i++) { void *buf; duk_size_t len; len = (duk_size_t) 0xdeadbeef; buf = duk_get_buffer(ctx, i, &len); if (len == 0) { /* avoid printing 'buf' if len is zero, as it is not predictable */ printf("index %ld: length 0\n", (long) i); } else { printf("index %ld: length %lu, ptr-is-NULL %d\n", (long) i, (unsigned long) len, (buf == NULL ? 1 : 0)); } } }
int test_1(duk_context *ctx) { int i, n; 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: %d\n", n); for (i = 0; i < n; i++) { duk_to_undefined(ctx, i); printf("index %d, is-undefined: %d\n", i, duk_is_undefined(ctx, i)); } return 0; }
static duk_ret_t nsp_texture_constructor(duk_context *ctx) { int width = duk_require_int(ctx, 0); int height = duk_require_int(ctx, 1); if (width < 1 || height < 1) { duk_push_error_object(ctx, DUK_ERR_RANGE_ERROR, "Width and height must be positive"); duk_throw(ctx); } bool has_transparency; uint16_t transparent_color; if ((has_transparency = duk_is_number(ctx, 2))) { transparent_color = (uint16_t)duk_get_int(ctx, 2); } duk_push_this(ctx); duk_push_fixed_buffer(ctx, width * height * 2); duk_put_prop_string(ctx, -2, "bitmap"); duk_push_int(ctx, width); duk_put_prop_string(ctx, -2, "width"); duk_push_int(ctx, height); duk_put_prop_string(ctx, -2, "height"); if (has_transparency) { duk_push_int(ctx, transparent_color); } else { duk_push_null(ctx); } duk_put_prop_string(ctx, -2, "transparentColor"); return 0; }
void como_push_worker_value (duk_context *ctx, comoQueue *queue){ switch(queue->type){ case DUK_TYPE_UNDEFINED : duk_push_undefined(ctx); break; case DUK_TYPE_NULL : duk_push_null(ctx); break; case DUK_TYPE_OBJECT : duk_push_string(ctx, queue->data); duk_json_decode(ctx, -1); break; case DUK_TYPE_POINTER : duk_push_pointer(ctx, queue->data); break; case DUK_TYPE_STRING : duk_push_string(ctx, queue->data); break; default : assert(0 && "Duk Type Error"); } }
static duk_ret_t test_nargs_minus1(duk_context *ctx, void *udata) { duk_int_t rc; (void) udata; duk_push_null(ctx); duk_push_null(ctx); duk_push_null(ctx); printf("top before: %ld\n", (long) duk_get_top(ctx)); rc = duk_safe_call(ctx, dummy, NULL, -1 /*nargs, negative*/, 0 /*nrets*/); printf("duk_safe_call rc: %ld\n", (long) rc); printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
int test_2b(duk_context *ctx) { duk_set_top(ctx, 0); duk_push_null(ctx); duk_to_object(ctx, 0); printf("index 0 OK\n"); return 0; }
JNIEXPORT jobject JNICALL Java_com_furture_react_DuktapeEngine_nativeCallJs (JNIEnv *env, jobject thisObject, jlong ptr, jstring jsTarget, jstring jsMethod, jobjectArray args){ duk_context *ctx = convert_to_context(ptr); jboolean iscopy = JNI_FALSE; const char* targetName = ((*env)->GetStringUTFChars(env, jsTarget, &iscopy)); DEBUG_LOG("ScriptEngine","Java_com_furture_react_DuktapeEngine_nativeCallJs call on %s", targetName); duk_push_global_object(ctx); if(duk_get_prop_string(ctx, -1, targetName)){ const char* methodName = ((*env)->GetStringUTFChars(env, jsMethod, &iscopy)); duk_push_string(ctx, methodName); jsize length = duk_push_java_object_array(ctx, env, args); DEBUG_LOG("ScriptEngine","Java_com_furture_react_DuktapeEngine_nativeCallJs call Function %d", length); if(duk_pcall_prop(ctx, -2 - length, length) != DUK_EXEC_SUCCESS){ LOGE("ScriptEngine","ScriptEngine CallJS %s.%s() method %s", targetName, methodName, duk_js_error_to_string(ctx, -1)); duk_pop(ctx); duk_push_null(ctx); } (*env)->ReleaseStringUTFChars(env, jsTarget, targetName); (*env)->ReleaseStringUTFChars(env, jsMethod, methodName); jobject value = duk_to_java_object(ctx, env, -1); duk_pop_2(ctx); return value; } (*env)->ReleaseStringUTFChars(env, jsTarget, targetName); duk_pop_2(ctx); return NULL; }
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; }
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 int java_object_to_string(duk_context *ctx) { int n = duk_get_top(ctx); DEBUG_LOG("ScriptEngine", "java_object_to_string enter %d", n); duk_push_this(ctx); if(duk_get_prop_string(ctx, -1, JAVA_OBJECT_MARK)){ DEBUG_LOG("ScriptEngine", "java_object_to_string enter java object "); jobject ref = duk_to_pointer(ctx, -1); if(ref == NULL){ duk_push_null(ctx); return 1; } JNIEnv* env = get_java_jni_env(); DEBUG_LOG("ScriptEngine", "java_object_to_string enter java end"); jclass refClass = (*env)->GetObjectClass(env, ref); jmethodID method = (*env)->GetMethodID(env, refClass, "toString", "()Ljava/lang/String;"); jstring value = (*env)->CallObjectMethod(env, ref, method); jboolean iscopy = JNI_FALSE; const char* src = ((*env)->GetStringUTFChars(env, value, &iscopy)); DEBUG_LOG("ScriptEngine", "java_object_to_string src %s", src ); duk_push_string(ctx, src); (*env)->ReleaseStringUTFChars(env, value, src); (*env)->DeleteLocalRef(env, value); (*env)->DeleteLocalRef(env, refClass); DEBUG_LOG("ScriptEngine", "java_object_to_string success"); return 1; }else{ DEBUG_LOG("ScriptEngine", "java_object_to_string error"); } return 0; }
/* Shared helper to implement Object.getPrototypeOf and the ES6 * Object.prototype.__proto__ getter. * * https://people.mozilla.org/~jorendorff/es6-draft.html#sec-get-object.prototype.__proto__ */ DUK_INTERNAL duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx) { duk_hobject *h; duk_hobject *proto; /* magic: 0=getter call, 1=Object.getPrototypeOf */ if (duk_get_current_magic(ctx) == 0) { duk_push_this_coercible_to_object(ctx); duk_insert(ctx, 0); } h = duk_require_hobject_or_lfunc(ctx, 0); /* h is NULL for lightfunc */ /* XXX: should the API call handle this directly, i.e. attempt * to duk_push_hobject(ctx, null) would push a null instead? * (On the other hand 'undefined' would be just as logical, but * not wanted here.) */ if (h == NULL) { duk_push_hobject_bidx(ctx, DUK_BIDX_FUNCTION_PROTOTYPE); } else { proto = DUK_HOBJECT_GET_PROTOTYPE(h); if (proto) { duk_push_hobject(ctx, proto); } else { duk_push_null(ctx); } } return 1; }
static duk_ret_t test_invalid_null(duk_context *ctx, void *udata) { (void) udata; duk_push_null(ctx); duk_push_buffer_object(ctx, -1, 7, 512, DUK_BUFOBJ_UINT32ARRAY); printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
void duv_push_status(duk_context *ctx, int status) { if (status < 0) { duk_push_error_object(ctx, DUK_ERR_ERROR, "%s: %s", uv_err_name(status), uv_strerror(status)); } else { duk_push_null(ctx); } }
static duk_ret_t test_1(duk_context *ctx, void *udata) { (void) udata; duk_set_top(ctx, 0); duk_push_null(ctx); duk_require_null(ctx, 0); return 0; }
static duk_ret_t test_3(duk_context *ctx) { duk_push_null(ctx); printf("%ld\n", (long) duk_is_primitive(ctx, 0)); /* valid */ printf("%ld\n", (long) duk_is_primitive(ctx, 1)); /* invalid */ printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
void PushWeakObject(duk_context* ctx, Object* object) { if (!object) { duk_push_null(ctx); return; } duk_push_heap_stash(ctx); // Check if the wrapper for the object already exists in stash // This is required so that comparisons of object references (e.g. against the me property) work properly if (duk_has_prop_index(ctx, -1, (size_t)object)) { duk_get_prop_index(ctx, -1, (size_t)object); WeakPtr<Object>* oldPtr = GetWeakPtr(ctx, -1); if (oldPtr && oldPtr->Get() == object) { duk_remove(ctx, -2); // Remove stash return; } else duk_pop(ctx); // Valid existing wrapper not found } duk_push_object(ctx); WeakPtr<Object>* ptr = new WeakPtr<Object>(object); duk_push_pointer(ctx, ptr); duk_put_prop_string(ctx, -2, "\xff""weak"); duk_push_c_function(ctx, WeakPtr_Finalizer, 1); duk_set_finalizer(ctx, -2); // Set prototype. If not found, use base class prototype (e.g. IComponent) duk_get_global_string(ctx, object->GetTypeName().CString()); if (!duk_is_object(ctx, -1)) { duk_pop(ctx); duk_get_global_string(ctx, object->GetTypeInfo()->GetBaseTypeInfo()->GetTypeName().CString()); } duk_get_prop_string(ctx, -1, "prototype"); duk_set_prototype(ctx, -3); duk_pop(ctx); // Proxied property access handling for scene, entity & component if (object->GetType() == Scene::GetTypeStatic()) SetupProxy(ctx, SceneProxyFunctions); if (object->GetType() == Entity::GetTypeStatic()) SetupProxy(ctx, EntityProxyFunctions); else if (dynamic_cast<IComponent*>(object)) SetupProxy(ctx, ComponentProxyFunctions); // Store to stash duk_dup(ctx, -1); duk_put_prop_index(ctx, -3, (size_t)object); duk_remove(ctx, -2); // Remove stash }
static duk_ret_t test_1(duk_context *ctx, void *udata) { (void) udata; duk_eval_string_noresult(ctx, "this.myFinalizer = function myfin(o) {\n" " print('finalizer, rescuing object', JSON.stringify(o));\n" " var global = new Function('return this')();\n" " global.rescued = o;\n" "}\n" ); /* First call; object gets finalized when call returns and call * handling does a duk_set_top() call. The object is rescued and * later reused. */ duk_push_c_function(ctx, my_func, 3 /*nargs*/); duk_push_null(ctx); duk_eval_string(ctx, "(function () {\n" " var res = { name: 'my object' };\n" " Duktape.fin(res, myFinalizer);\n" " return res;\n" "})()\n"); duk_push_null(ctx); printf("calling\n"); duk_call(ctx, 3); printf("returned\n"); duk_pop(ctx); /* Object is reused for another call, and rescued again. */ duk_push_c_function(ctx, my_func, 3 /*nargs*/); duk_push_null(ctx); duk_eval_string(ctx, "rescued"); duk_eval_string_noresult(ctx, "rescued = null;"); duk_push_null(ctx); printf("calling\n"); duk_call(ctx, 3); printf("returned\n"); duk_pop(ctx); printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
static duk_ret_t test_nrets_too_large(duk_context *ctx, void *udata) { duk_int_t rc; (void) udata; duk_push_null(ctx); duk_push_null(ctx); duk_push_null(ctx); printf("top before: %ld\n", (long) duk_get_top(ctx)); /* Here 'nrets' is too large, beyond the current value stack * reserve. (This succeeds in Duktape 2.1 and prior because * the implementation did a reserve check.) */ rc = duk_safe_call(ctx, dummy, NULL, 2 /*nargs*/, 1024 /*nrets, too large*/); printf("duk_safe_call rc: %ld\n", (long) rc); printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
/* duk_del_prop_string(), not object coercible */ static duk_ret_t test_delpropstring_g(duk_context *ctx) { duk_ret_t rc; duk_set_top(ctx, 0); duk_push_null(ctx); rc = duk_del_prop_string(ctx, -1, "foo"); printf("delete null.foo -> rc=%d\n", (int) rc); printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
int test_2(duk_context *ctx) { const char *p; size_t sz; duk_set_top(ctx, 0); duk_push_null(ctx); p = duk_require_lstring(ctx, 0, &sz); printf("string: %s (%d)\n", p, (int) sz); return 0; }
int test_2(duk_context *ctx) { void *ptr; size_t sz; duk_set_top(ctx, 0); duk_push_null(ctx); sz = (size_t) 0xdeadbeef; ptr = duk_require_buffer(ctx, 0, &sz); printf("buffer ok: %p\n", ptr); /* ok to print, should not be reached */ return 0; }