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));
}
}
}
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));
}
}
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 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;
}
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 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 Component_SetProperty(duk_context* ctx)
{
/* 'this' binding: handler
* [0]: target
* [1]: key
* [2]: val
* [3]: receiver (proxy)
*/
const char* attrName = duk_to_string(ctx, 1);
if (attrName && attrName[0] >= 'a' && attrName[0] <= 'z')
{
IComponent* comp = GetWeakObject<IComponent>(ctx, 0);
if (comp)
{
IAttribute* attr = comp->AttributeById(String(attrName));
AssignAttributeValue(ctx, 2, attr, AttributeChange::Default);
return 1;
}
}
// Fallthrough to ordinary properties
duk_dup(ctx, 1);
duk_dup(ctx, 2);
duk_put_prop(ctx, 0);
duk_push_true(ctx);
return 1;
}
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 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_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_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, 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;
}
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) {
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_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 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) {
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;
}
static duk_int_t duk__eval_module_source(duk_context *ctx, void *udata) {
#else
static duk_int_t duk__eval_module_source(duk_context *ctx) {
#endif
/*
* Stack: [ ... module source ]
*/
#if DUK_VERSION >= 19999
(void) udata;
#endif
/* Wrap the module code in a function expression. This is the simplest
* way to implement CommonJS closure semantics and matches the behavior of
* e.g. Node.js.
*/
duk_push_string(ctx, "(function(exports,require,module,__filename,__dirname){");
duk_dup(ctx, -2); /* source */
duk_push_string(ctx, "})");
duk_concat(ctx, 3);
/* [ ... module source func_src ] */
(void) duk_get_prop_string(ctx, -3, "filename");
duk_compile(ctx, DUK_COMPILE_EVAL);
duk_call(ctx, 0);
/* [ ... module source func ] */
/* Set name for the wrapper function. */
duk_push_string(ctx, "name");
duk_push_string(ctx, "main");
duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_FORCE);
/* call the function wrapper */
(void) duk_get_prop_string(ctx, -3, "exports"); /* exports */
(void) duk_get_prop_string(ctx, -4, "require"); /* require */
duk_dup(ctx, -5); /* module */
(void) duk_get_prop_string(ctx, -6, "filename"); /* __filename */
duk_push_undefined(ctx); /* __dirname */
duk_call(ctx, 5);
/* [ ... module source result(ignore) ] */
/* module.loaded = true */
duk_push_true(ctx);
duk_put_prop_string(ctx, -4, "loaded");
/* [ ... module source retval ] */
duk_pop_2(ctx);
/* [ ... module ] */
return 1;
}
static duk_ret_t req_valid_idx(duk_context *ctx) {
duk_idx_t idx = duk_get_int(ctx, -1);
duk_pop(ctx);
printf("req_valid_idx: top %ld after popping arg\n", (long) duk_get_top(ctx));
duk_require_valid_index(ctx, idx);
duk_push_true(ctx);
return 1;
}
void test(duk_context *ctx) {
duk_push_string(ctx, "; ");
duk_push_string(ctx, "foo");
duk_push_int(ctx, 123);
duk_push_true(ctx);
duk_join(ctx, 3);
printf("result: %s\n", duk_get_string(ctx, -1));
duk_pop(ctx);
}
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;
}
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_sealed_frozen_shared(duk_context *ctx) {
duk_hobject *h;
duk_bool_t is_frozen;
duk_bool_t rc;
h = duk_require_hobject_or_lfunc(ctx, 0);
if (!h) {
duk_push_true(ctx); /* frozen and sealed */
} else {
is_frozen = duk_get_current_magic(ctx);
rc = duk_hobject_object_is_sealed_frozen_helper(h, is_frozen /*is_frozen*/);
duk_push_boolean(ctx, rc);
}
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;
}
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_prevent_extensions(duk_context *ctx) {
/*
* magic = 0: Object.preventExtensions()
* magic = 1: Reflect.preventExtensions()
*/
duk_hthread *thr = (duk_hthread *) ctx;
duk_hobject *h;
duk_uint_t mask;
duk_int_t magic;
magic = duk_get_current_magic(ctx);
/* Silent success for lightfuncs and plain buffers always. */
mask = DUK_TYPE_MASK_LIGHTFUNC | DUK_TYPE_MASK_BUFFER;
/* Object.preventExtensions() silent success for non-object. */
if (magic == 0) {
mask |= DUK_TYPE_MASK_UNDEFINED |
DUK_TYPE_MASK_NULL |
DUK_TYPE_MASK_BOOLEAN |
DUK_TYPE_MASK_NUMBER |
DUK_TYPE_MASK_STRING |
DUK_TYPE_MASK_POINTER;
}
if (duk_check_type_mask(ctx, 0, mask)) {
/* Not an object, already non-extensible so always success. */
goto done;
}
h = duk_require_hobject(ctx, 0);
DUK_ASSERT(h != NULL);
DUK_HOBJECT_CLEAR_EXTENSIBLE(h);
/* A non-extensible object cannot gain any more properties,
* so this is a good time to compact.
*/
duk_hobject_compact_props(thr, h);
done:
if (magic == 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, 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;
}
