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)); } }
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)); } } }
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; }
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"); }
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; }
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) { 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; }
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 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 dukzip_zip_write(duk_context *ctx) { int res = ZIP_OK; zipFile archive = dukzip_zip_from_this(ctx); if (duk_is_string(ctx, 0)) { int outputl = 0; const char *output = duk_get_lstring(ctx, 0, &outputl); res = zipWriteInFileInZip(archive, output, outputl); } else if (duk_is_buffer(ctx, 0) || duk_is_object(ctx, 0)) { int outputl = 0; void *output = duk_require_buffer_data(ctx, 0, &outputl); res = zipWriteInFileInZip(archive, output, outputl); } else { duk_error(ctx, DUK_ERR_TYPE_ERROR, "unable to write argument to zip file (supported types: string, buffer)"); return -1; } if (res == ZIP_OK) { duk_push_true(ctx); } else { duk_push_false(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_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 dukzip_zip_newfile(duk_context *ctx) { zip_fileinfo zi = {0}; int res = ZIP_OK; zipFile archive = dukzip_zip_from_this(ctx); const char *filename = ""; duk_int_t level = Z_DEFAULT_COMPRESSION; duk_int_t method = Z_DEFLATED; const char *comment = ""; if (duk_is_object(ctx, 0)) { dukzip_zip_checkoptions(ctx, 0, &filename, &level, &method, &comment); } else { filename = duk_require_string(ctx, 0); if (duk_is_number(ctx, 1)) { level = duk_get_int(ctx, 1); } } res = zipOpenNewFileInZip64(archive, filename, &zi, NULL, 0, NULL, 0, comment, method, level, 1); if (res == ZIP_OK) { duk_push_true(ctx); } else { duk_push_false(ctx); } return 1; }
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; }
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; }
static duk_ret_t test_1(duk_context *ctx) { duk_set_top(ctx, 0); duk_push_true(ctx); duk_push_false(ctx); printf("boolean: %d\n", (int) duk_require_boolean(ctx, 0)); printf("boolean: %d\n", (int) duk_require_boolean(ctx, 1)); return 0; }
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_extensible(duk_context *ctx) { duk_hobject *h; h = duk_require_hobject_or_lfunc(ctx, 0); if (!h) { duk_push_false(ctx); } else { duk_push_boolean(ctx, DUK_HOBJECT_HAS_EXTENSIBLE(h)); } return 1; }
static duk_ret_t dukzip_unz_getnextfile(duk_context *ctx) { unzFile archive = dukzip_unz_from_this(ctx); int res = unzGoToNextFile(archive); if (res == UNZ_OK) { duk_push_true(ctx); } else { duk_push_false(ctx); } return 1; }
static duk_ret_t dukzip_unz_getfile(duk_context *ctx) { unzFile archive = dukzip_unz_from_this(ctx); const char *filename = duk_require_string(ctx, 0); int res = unzLocateFile(archive, filename, 0); if (res == UNZ_OK) { duk_push_true(ctx); } else { duk_push_false(ctx); } return 1; }
static duk_ret_t dukzip_zip_close(duk_context *ctx) { int res = ZIP_OK; zipFile archive = dukzip_zip_from_this(ctx); res = zipCloseFileInZip(archive); if (res == ZIP_OK) { duk_push_true(ctx); } else { duk_push_false(ctx); } return 1; }
static duk_ret_t native_prime_check(duk_context *ctx) { int val = duk_require_int(ctx, 0); int lim = duk_require_int(ctx, 1); int i; for (i = 2; i <= lim; i++) { if (val % i == 0) { duk_push_false(ctx); return 1; } } duk_push_true(ctx); return 1; }
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, 1); duk_push_number(ctx, -123.456); duk_push_nan(ctx); duk_push_number(ctx, INFINITY); duk_push_string(ctx, ""); duk_push_string(ctx, "foo"); duk_push_string(ctx, "123"); duk_push_string(ctx, "123.456"); duk_push_string(ctx, "123.456e3"); duk_push_string(ctx, " -123.456e+3 "); duk_push_string(ctx, "NaN"); duk_push_string(ctx, "-Infinity"); duk_push_string(ctx, "+Infinity"); duk_push_string(ctx, "Infinity"); duk_push_string(ctx, "Infinityx"); duk_push_string(ctx, "xInfinity"); duk_push_string(ctx, " Infinity "); duk_push_object(ctx); duk_push_thread(ctx); duk_push_fixed_buffer(ctx, 0); /* coerces like string: ToNumber('') = 0 */ duk_push_fixed_buffer(ctx, 1024); /* coerces like string: ToNumber('\u0000\u0000...') = NaN */ duk_push_dynamic_buffer(ctx, 0); duk_push_dynamic_buffer(ctx, 1024); 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++) { printf("index %ld, number: %lf\n", (long) i, (double) duk_to_number(ctx, i)); } return 0; }
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 *) 0xdeadbeefUL); n = duk_get_top(ctx); printf("top: %ld\n", (long) n); for (i = 0; i < n; i++) { void *ptr; duk_int_t t1, t2; t1 = duk_get_type(ctx, i); ptr = duk_to_pointer(ctx, i); t2 = duk_get_type(ctx, i); printf("index %ld, ptr-is-NULL: %d, type: %ld -> %ld\n", (long) i, (ptr == NULL ? 1 : 0), (long) t1, (long) t2); if (t1 == DUK_TYPE_POINTER) { /* check that pointer is retained as is (can safely print) */ printf("pointer: %p\n", ptr); } } return 0; }
static duk_ret_t handle_delete(duk_context *ctx) { /* 'this' binding: handler * [0]: target * [1]: key */ const char *key = duk_to_string(ctx, 1); printf("handle_delete: key=%s\n", key); if (key != NULL && key[0] == '_') { /* Indicate delete failure for properties beginning with underscore. */ duk_push_false(ctx); } else { duk_push_true(ctx); } return 1; }
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, ""); 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); duk_eval_string(ctx, "(function () { return new ArrayBuffer(16); })()"); duk_eval_string(ctx, "(function () { return new Uint32Array(16); })()"); duk_eval_string(ctx, "(function () { return new DataView(new ArrayBuffer(16)); })()"); duk_eval_string(ctx, "(function () { return new Uint32Array(16).subarray(3, 6); })()"); duk_eval_string(ctx, "(function () { return new Buffer('ABCDEFGH'); })()"); duk_eval_string(ctx, "(function () { return new Buffer('ABCDEFGH').slice(3, 6); })()"); n = duk_get_top(ctx); printf("top: %ld\n", (long) n); for (i = 0; i <= n; i++) { rc = duk_safe_call(ctx, safe_helper1, (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); rc = duk_safe_call(ctx, safe_helper2, (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; }
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_number(ctx, 123.456); duk_to_object(ctx, -1); /* Number(123.456) */ 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_int_t t1, t2; t1 = duk_get_type(ctx, i); duk_to_primitive(ctx, i, DUK_HINT_NONE); t2 = duk_get_type(ctx, i); printf("index %ld, ToString(result): '%s', type: %ld -> %ld\n", (long) i, duk_to_string(ctx, i), (long) t1, (long) t2); } return 0; }
static duk_ret_t test_basic(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); duk_eval_string(ctx, "(function () { return new ArrayBuffer(16); })()"); duk_eval_string(ctx, "(function () { return new Uint32Array(16); })()"); duk_eval_string(ctx, "(function () { return new DataView(new ArrayBuffer(16)); })()"); duk_eval_string(ctx, "(function () { return new Uint32Array(16).subarray(3, 6); })()"); duk_eval_string(ctx, "(function () { return new Buffer('ABCDEFGH'); })()"); duk_eval_string(ctx, "(function () { return new Buffer('ABCDEFGH').slice(3, 6); })()"); 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) 0xdeadbeefUL; buf = duk_get_buffer_data(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)); } } printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
duk_ret_t duk_bi_object_prototype_is_prototype_of(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; duk_hobject *h_v; duk_hobject *h_obj; DUK_ASSERT_TOP(ctx, 1); h_v = duk_get_hobject(ctx, 0); if (!h_v) { duk_push_false(ctx); /* XXX: tail call: return duk_push_false(ctx) */ return 1; } h_obj = duk_push_this_coercible_to_object(ctx); DUK_ASSERT(h_obj != NULL); /* E5.1 Section 15.2.4.6, step 3.a, lookup proto once before compare */ duk_push_boolean(ctx, duk_hobject_prototype_chain_contains(thr, h_v->prototype, h_obj)); return 1; }
void test(duk_context *ctx) { int 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_int(ctx, 123); duk_push_object(ctx); 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++) { void *ptr = duk_get_pointer(ctx, i); printf("index %d, pointer %p\n", i, ptr); } }