PoolStringArray args;

args.resize(argc);

for (int i = 0; i < argc; ++i) {

size_t size;

const char *utf8 = JS_ToCStringLen(ctx, &size, *(argv + i));

args.write()[i].parse_utf8(utf8, size);

JS_FreeCString(ctx, utf8);

}

switch (magic) {

case 2:

print_error(args.join(" "));

break;

case 1:

default:

print_line(args.join(" "));

break;

}

return JS_UNDEFINED;

JSValue console = JS_NewObject(ctx);

JSValue log = JS_NewCFunctionMagic(ctx, console_log_function, "log", 0, JS_CFUNC_generic_magic, 0);

JSValue warn = JS_NewCFunctionMagic(ctx, console_log_function, "warn", 0, JS_CFUNC_generic_magic, 1);

JSValue err = JS_NewCFunctionMagic(ctx, console_log_function, "warn", 0, JS_CFUNC_generic_magic, 2);

JS_DefinePropertyValueStr(ctx, global_object, "console", console, PROP_DEF_DEFAULT);

JS_DefinePropertyValueStr(ctx, console, "log", log, PROP_DEF_DEFAULT);

JS_DefinePropertyValueStr(ctx, console, "warn", warn, PROP_DEF_DEFAULT);

JS_DefinePropertyValueStr(ctx, console, "err", err, PROP_DEF_DEFAULT);

// globalThis.requestAnimationFrame

JSValue js_func_requestAnimationFrame = JS_NewCFunction(ctx, global_request_animation_frame, "requestAnimationFrame", 1);

JS_DefinePropertyValueStr(ctx, global_object, "requestAnimationFrame", js_func_requestAnimationFrame, PROP_DEF_DEFAULT);

// globalThis.cancelAnimationFrame

JSValue js_func_cancelAnimationFrame = JS_NewCFunction(ctx, global_cancel_animation_frame, "cancelAnimationFrame", 1);

JS_DefinePropertyValueStr(ctx, global_object, "cancelAnimationFrame", js_func_cancelAnimationFrame, PROP_DEF_DEFAULT);

ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);

ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "Call native method without native binding data"));

ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "Call native method without native object caller"));

Object *obj = bind->get_godot_object();

MethodBind *mb = get_context_binder(ctx)->godot_methods[method_id];

if (!mb->is_vararg()) {

argc = MIN(argc, mb->get_argument_count());

}

QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);

for (int i = 0; i < argc; ++i) {

binder->method_call_arguments[i] = var_to_variant(ctx, argv[i]);

}

Variant::CallError call_err;

Variant ret_val = mb->call(obj, binder->method_call_argument_ptrs, argc, call_err);

#ifdef DEBUG_METHODS_ENABLED

CharString err_message;

switch (call_err.error) {

case Variant::CallError::CALL_ERROR_INVALID_ARGUMENT: {

String err = "Invalid type for argument #" + itos(call_err.argument) + ", expected '" + Variant::get_type_name(call_err.expected) + "'.";

err_message = err.utf8();

} break;

case Variant::CallError::CALL_ERROR_INVALID_METHOD: {

String err = "Invalid method '" + String(mb->get_name()) + "' for type '" + obj->get_class_name() + "'.";

err_message = err.utf8();

} break;

case Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS: {

String err = "Too many arguments for method '" + String(mb->get_name()) + "'";

err_message = err.utf8();

} break;

default: {

}

}

ERR_FAIL_COND_V((call_err.error != Variant::CallError::CALL_OK), JS_ThrowTypeError(ctx, err_message.ptr()));

#endif

return variant_to_var(ctx, ret_val);

switch (p_var.get_type()) {

case Variant::BOOL:

return ((bool)p_var) ? JS_TRUE : JS_FALSE;

case Variant::INT:

return JS_NewInt32(ctx, int32_t(p_var));

case Variant::REAL:

return JS_NewFloat64(ctx, (double)(p_var));

case Variant::NODE_PATH:

case Variant::STRING:

return to_js_string(ctx, p_var);

case Variant::OBJECT: {

Object *obj = p_var;

ECMAScriptGCHandler *data = BINDING_DATA_FROM_GD(ctx, obj);

ERR_FAIL_NULL_V(data, JS_UNDEFINED);

ERR_FAIL_NULL_V(data->ecma_object, JS_UNDEFINED);

ERR_FAIL_COND_V(data->context != ctx, (JS_UNDEFINED));

QuickJSBinder *binder = get_context_binder(ctx);

JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, data->ecma_object);

if (binder->lastest_allocated_object == data) {

data->flags |= ECMAScriptGCHandler::FLAG_FROM_NATIVE;

binder->lastest_allocated_object = NULL;

}

JS_DupValue(ctx, js_obj);

return js_obj;

}

case Variant::ARRAY: {

Array arr = p_var;

JSValue js_arr = JS_NewArray(ctx);

for (uint32_t i = 0; i < arr.size(); i++) {

JS_SetPropertyUint32(ctx, js_arr, i, variant_to_var(ctx, arr[int(i)]));

}

return js_arr;

}

case Variant::DICTIONARY: {

Dictionary dict = p_var;

JSValue obj = JS_NewObject(ctx);

Array keys = dict.keys();

for (int i = 0; i < keys.size(); i++) {

const Variant &key = keys[i];

const Variant &value = dict[key];

String key_str = keys[i];

JS_SetPropertyStr(ctx, obj, key_str.utf8().ptr(), variant_to_var(ctx, value));

}

return obj;

}

case Variant::NIL:

return JS_NULL;

default:

return QuickJSBuiltinBinder::new_object_from(ctx, p_var);

}

switch (JS_VALUE_GET_TAG(p_val)) {

case JS_TAG_INT:

return Variant(JS_VALUE_GET_INT(p_val));

case JS_TAG_BOOL:

return Variant(bool(JS_VALUE_GET_INT(p_val)));

case JS_TAG_FLOAT64:

return Variant(real_t(JS_VALUE_GET_FLOAT64(p_val)));

case JS_TAG_STRING: {

return js_to_string(ctx, p_val);

}

case JS_TAG_OBJECT: {

int length = get_js_array_length(ctx, p_val);

if (length != -1) { // Array

Array arr;

arr.resize(length);

for (uint32_t i = 0; i < length; i++) {

JSValue val = JS_GetPropertyUint32(ctx, p_val, i);

arr[int(i)] = var_to_variant(ctx, val);

JS_FreeValue(ctx, val);

}

return arr;

} else if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, p_val)) { // Binding object

ERR_FAIL_NULL_V(bind, Variant());

ERR_FAIL_NULL_V(bind->godot_object, Variant());

return bind->get_value();

} else { // Plain Object as Dictionary

Dictionary dict;

Set<String> keys;

get_own_property_names(ctx, p_val, &keys);

for (Set<String>::Element *E = keys.front(); E; E = E->next()) {

JSValue v = JS_GetPropertyStr(ctx, p_val, E->get().utf8().ptr());

dict[E->get()] = var_to_variant(ctx, v);

JS_FreeValue(ctx, v);

}

return dict;

}

}

default:

return Variant();

}

Variant ret;

Variant::CallError err;

String err_msg;

Expression::BuiltinFunc func = (Expression::BuiltinFunc)magic;

int arg_required = Expression::get_func_argument_count(func);

if (argc < arg_required) {

String func_name = Expression::get_func_name(func);

return JS_ThrowTypeError(ctx, "%d arguments expected for builtin funtion %s", arg_required, func_name.ascii().ptr());

}

QuickJSBinder *binder = get_context_binder(ctx);

for (int i = 0; i < argc; ++i) {

binder->method_call_arguments[i] = var_to_variant(ctx, argv[i]);

}

Expression::exec_func(func, binder->method_call_argument_ptrs, &ret, err, err_msg);

if (err.error != Variant::CallError::CALL_OK) {

String func_name = Expression::get_func_name(func);

return JS_ThrowTypeError(ctx, "Call builtin function error %s: %s", func_name.ascii().ptr(), err_msg.utf8().ptr());

}

return variant_to_var(ctx, ret);

switch (p_type) {

case Variant::NIL:

return JS_IsNull(p_val) || JS_IsUndefined(p_val);

case Variant::BOOL:

case Variant::INT:

case Variant::REAL:

return JS_IsNumber(p_val) || JS_IsBool(p_val) || JS_IsNull(p_val) || JS_IsUndefined(p_val);

case Variant::STRING:

return JS_IsString(p_val);

case Variant::DICTIONARY:

return JS_IsObject(p_val);

case Variant::ARRAY:

return JS_IsArray(ctx, p_val);

default: {

ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, p_val);

return bind != NULL && bind->type == bind->type;

}

}

JSValue err_file = JS_GetProperty(ctx, p_exception, JS_ATOM_fileName);

JSValue err_line = JS_GetProperty(ctx, p_exception, JS_ATOM_lineNumber);

JSValue err_msg = JS_GetProperty(ctx, p_exception, JS_ATOM_message);

JSValue err_stack = JS_GetProperty(ctx, p_exception, JS_ATOM_stack);

JS_ToInt32(ctx, &r_error->line, err_line);

r_error->message = js_to_string(ctx, err_msg);

r_error->file = js_to_string(ctx, err_file);

r_error->stack.push_back(js_to_string(ctx, err_stack));

r_error->column = 0;

JS_FreeValue(ctx, err_file);

JS_FreeValue(ctx, err_line);

JS_FreeValue(ctx, err_msg);

JS_FreeValue(ctx, err_stack);

String message = "JavaScript Error";

if (p_error.stack.size()) {

message += p_error.stack[0];

}

message += p_error.message;

for (int i = 1; i < p_error.stack.size(); i++) {

message += p_error.stack[i];

}

return message;

String name = p_key;

CharString name_str = name.ascii();

JSAtom atom = JS_NewAtom(ctx, name_str.ptr());

return atom;

String str = var_to_variant(ctx, this_val);

CharString ascii = str.ascii();

return JS_NewStringLen(ctx, ascii.ptr(), ascii.length());

#ifdef DEBUG_METHODS_ENABLED

ERR_FAIL_COND_V(argc < 1, JS_ThrowTypeError(ctx, "parameter expected for %s.%s", GODOT_OBJECT_NAME, "get_type"));

#endif

Variant value;

if (argc) {

value = var_to_variant(ctx, argv[0]);

}

return JS_NewInt32(ctx, value.get_type());

#ifdef DEBUG_METHODS_ENABLED

ERR_FAIL_COND_V(argc < 1 || !JS_IsString(argv[0]), JS_ThrowTypeError(ctx, "string expected for %s.%s", GODOT_OBJECT_NAME, "load"));

#endif

String path = js_to_string(ctx, argv[0]);

RES res = ResourceLoader::load(path);

return variant_to_var(ctx, res);

if (!p_bind) return;

JSValue classname = JS_UNDEFINED;

if (p_bind->type != Variant::OBJECT) {

classname = to_js_string(ctx, Variant::get_type_name(p_bind->type));

} else {

if (p_bind->is_reference()) {

classname = to_js_string(ctx, (*p_bind->godot_reference)->get_class_name());

} else if (p_bind->is_object()) {

classname = to_js_string(ctx, p_bind->godot_object->get_class_name());

}

}

Array arr;

String ptr_str = "0x%X";

bool err;

union {

const void *p;

uint64_t i;

} u;

u.p = p_bind->godot_object;

arr.push_back(int(u.i));

ptr_str = ptr_str.sprintf(arr, &err);

JSValue ptrvalue = to_js_string(ctx, ptr_str);

u.p = ctx;

arr[0] = int(u.i);

ptr_str = "0x%X";

ptr_str = ptr_str.sprintf(arr, &err);

JSValue ptrctx = to_js_string(ctx, ptr_str);

JS_DefinePropertyValueStr(ctx, p_obj, "__class__", classname, PROP_DEF_DEFAULT);

JS_DefinePropertyValueStr(ctx, p_obj, "__ptr__", ptrvalue, PROP_DEF_DEFAULT);

JS_DefinePropertyValueStr(ctx, p_obj, "__ctx__", ptrctx, PROP_DEF_DEFAULT);

ClassBindData data;

data.class_id = 0;

data.base_class = NULL;

if (class_remap.has(p_cls->name)) {

data.class_name = class_remap[p_cls->name];

data.jsclass.class_name = class_remap[p_cls->name];

if (data.jsclass.class_name == "") {

return 0;

}

} else {

data.class_name = String(p_cls->name).ascii();

data.jsclass.class_name = data.class_name.ptr();

}

data.jsclass.exotic = NULL;

data.jsclass.gc_mark = NULL;

data.jsclass.call = NULL;

data.gdclass = p_cls;

data.prototype = JS_NewObject(ctx);

// methods

Map<StringName, JSValue> methods;

{

godot_methods.resize(internal_godot_method_id + p_cls->method_map.size());

const StringName *key = p_cls->method_map.next(NULL);

while (key) {

MethodBind *mb = p_cls->method_map.get(*key);

godot_methods.write[internal_godot_method_id] = mb;

CharString name = String(*key).ascii();

JSValue method = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_method, name.ptr(), mb->get_argument_count(), JS_CFUNC_generic_magic, internal_godot_method_id);

JS_DefinePropertyValueStr(ctx, data.prototype, name.ptr(), method, PROP_DEF_DEFAULT);

methods.insert(*key, method);

++internal_godot_method_id;

key = p_cls->method_map.next(key);

}

if (p_cls->name == "Object") {

// toString()

JSValue to_string_func = JS_NewCFunction(ctx, godot_to_string, TO_STRING_LITERAL, 0);

JS_DefinePropertyValueStr(ctx, data.prototype, TO_STRING_LITERAL, to_string_func, PROP_DEF_DEFAULT);

// free()

const char *free_func_name = "free";

JSValue free_func = JS_NewCFunction(ctx, object_free, free_func_name, 0);

JS_DefinePropertyValueStr(ctx, data.prototype, free_func_name, free_func, PROP_DEF_DEFAULT);

}

}

// properties

{

const StringName *key = p_cls->property_setget.next(NULL);

while (key) {

const StringName &prop_name = *key;

const ClassDB::PropertySetGet &prop = p_cls->property_setget[prop_name];

JSValue *setter = NULL;

JSValue *getter = NULL;

if (Map<StringName, JSValue>::Element *E = methods.find(prop.setter)) {

setter = &(E->get());

JS_DupValue(ctx, *setter);

}

if (Map<StringName, JSValue>::Element *E = methods.find(prop.getter)) {

getter = &(E->get());

JS_DupValue(ctx, *getter);

}

JSAtom atom = get_atom(ctx, prop_name);

JS_DefinePropertyGetSet(ctx, data.prototype, atom, getter ? *getter : JS_UNDEFINED, setter ? *setter : JS_UNDEFINED, PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, atom);

key = p_cls->property_setget.next(key);

}

}

JS_NewClassID(&data.class_id);

JS_NewClass(JS_GetRuntime(ctx), data.class_id, &data.jsclass);

JS_SetClassProto(ctx, data.class_id, data.prototype);

data.constructor = JS_NewCFunctionMagic(ctx, object_constructor, data.jsclass.class_name, data.class_name.size(), JS_CFUNC_constructor_magic, (int)data.class_id);

JS_SetConstructor(ctx, data.constructor, data.prototype);

JS_DefinePropertyValue(ctx, data.prototype, js_key_godot_classid, JS_NewInt32(ctx, data.class_id), PROP_DEF_DEFAULT);

JS_DefinePropertyValue(ctx, data.constructor, js_key_godot_classid, JS_NewInt32(ctx, data.class_id), PROP_DEF_DEFAULT);

// constants

{

const StringName *key = p_cls->constant_map.next(NULL);

while (key) {

int value = p_cls->constant_map.get(*key);

JSAtom atom = get_atom(ctx, *key);

JS_DefinePropertyValue(ctx, data.constructor, atom, JS_NewInt32(ctx, value), PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, atom);

key = p_cls->constant_map.next(key);

}

}

// enumeration

{

const StringName *key = p_cls->enum_map.next(NULL);

while (key) {

JSValue enum_obj = JS_NewObject(ctx);

JSAtom atom = get_atom(ctx, *key);

const List<StringName> &const_keys = p_cls->enum_map.get(*key);

for (const List<StringName>::Element *E = const_keys.front(); E; E = E->next()) {

int value = p_cls->constant_map.get(E->get());

JSAtom atom_key = get_atom(ctx, E->get());

JS_DefinePropertyValue(ctx, enum_obj, atom_key, JS_NewInt32(ctx, value), PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, atom_key);

}

JS_DefinePropertyValue(ctx, data.constructor, atom, enum_obj, PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, atom);

key = p_cls->enum_map.next(key);

}

}

// signals

{

const StringName *key = p_cls->signal_map.next(NULL);

while (key) {

JSAtom atom = get_atom(ctx, *key);

JS_DefinePropertyValue(ctx, data.constructor, atom, to_js_string(ctx, *key), PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, atom);

key = p_cls->signal_map.next(key);

}

}

class_bindings.set(data.class_id, data);

classname_bindings.set(p_cls->name, class_bindings.getptr(data.class_id));

return data.class_id;

godot_origin_class.class_id = 0;

godot_origin_class.class_name = "GodotOrigin";

godot_origin_class.jsclass.class_name = godot_origin_class.class_name.ptr();

godot_origin_class.jsclass.finalizer = origin_finalizer;

godot_origin_class.jsclass.exotic = NULL;

godot_origin_class.jsclass.call = NULL;

godot_origin_class.jsclass.gc_mark = NULL;

godot_origin_class.prototype = JS_NewObject(ctx);

godot_origin_class.gdclass = NULL;

godot_origin_class.base_class = NULL;

JS_NewClassID(&godot_origin_class.class_id);

JS_NewClass(JS_GetRuntime(ctx), godot_origin_class.class_id, &godot_origin_class.jsclass);

JS_SetClassProto(ctx, godot_origin_class.class_id, godot_origin_class.prototype);

godot_origin_class.constructor = JS_NewCFunction2(ctx, js_empty_consturctor, godot_origin_class.jsclass.class_name, 0, JS_CFUNC_constructor, 0);

JS_SetConstructor(ctx, godot_origin_class.constructor, godot_origin_class.prototype);

JS_DefinePropertyValueStr(ctx, godot_object, godot_origin_class.class_name, godot_origin_class.constructor, PROP_DEF_DEFAULT);

Map<const ClassDB::ClassInfo *, JSClassID> gdclass_jsmap;

// register classes

const StringName *key = ClassDB::classes.next(NULL);

while (key) {

const ClassDB::ClassInfo *cls = ClassDB::classes.getptr(*key);

if (JSClassID id = register_class(cls)) {

gdclass_jsmap.insert(cls, id);

}

key = ClassDB::classes.next(key);

}

// Setup inherits chain

for (Map<const ClassDB::ClassInfo *, JSClassID>::Element *E = gdclass_jsmap.front(); E; E = E->next()) {

const ClassDB::ClassInfo *gdcls = E->key();

ClassBindData &bind = class_bindings.get(E->get());

if (gdcls->inherits_ptr) {

if (Map<const ClassDB::ClassInfo *, JSClassID>::Element *base = gdclass_jsmap.find(gdcls->inherits_ptr)) {

bind.base_class = class_bindings.getptr(base->get());

}

}

}

// Setup the prototype chain

const JSClassID *id = class_bindings.next(NULL);

while (id) {

const ClassBindData &data = class_bindings.get(*id);

int flags = PROP_DEF_DEFAULT;

// Allows redefine as to global object

if (Engine::get_singleton()->has_singleton(data.gdclass->name)) {

flags |= JS_PROP_CONFIGURABLE;

}

JS_DefinePropertyValueStr(ctx, godot_object, data.jsclass.class_name, data.constructor, flags);

if (data.base_class) {

JS_SetPrototype(ctx, data.prototype, data.base_class->prototype);

} else {

JS_SetPrototype(ctx, data.prototype, godot_origin_class.prototype);

}

id = class_bindings.next(id);

}

godot_object_class = *classname_bindings.getptr("Object");

// Singletons

List<Engine::Singleton> singletons;

Engine::get_singleton()->get_singletons(&singletons);

for (List<Engine::Singleton>::Element *E = singletons.front(); E; E = E->next()) {

const Engine::Singleton &s = E->get();

ERR_CONTINUE(s.ptr == NULL);

const ClassBindData **cls_ptr = classname_bindings.getptr(s.ptr->get_class_name());

ERR_CONTINUE(cls_ptr == NULL);

const ClassBindData *cls = *cls_ptr;

JSValue obj = JS_NewObjectProtoClass(ctx, cls->prototype, get_origin_class_id());

ECMAScriptGCHandler *data = new_gc_handler(ctx);

data->ecma_object = JS_VALUE_GET_PTR(obj);

data->godot_object = s.ptr;

data->type = Variant::OBJECT;

data->flags = ECMAScriptGCHandler::FLAG_OBJECT;

JS_SetOpaque(obj, data);

JSAtom singleton_name = get_atom(ctx, s.name);

JSValue last_obj = JS_GetProperty(ctx, godot_object, singleton_name);

if (!JS_IsUndefined(last_obj)) {

JS_SetPrototype(ctx, obj, cls->prototype);

JS_FreeValue(ctx, last_obj);

}

JS_DupValue(ctx, obj);

JS_DefinePropertyValue(ctx, godot_object, singleton_name, obj, QuickJSBinder::PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, singleton_name);

godot_singletons.push_back(obj);

if (ClassDB::ClassInfo *cls = ClassDB::classes.getptr(s.ptr->get_class_name())) {

// constants

for (const StringName *const_key = cls->constant_map.next(NULL); const_key; const_key = cls->constant_map.next(const_key)) {

JSAtom const_name = get_atom(ctx, *const_key);

JS_DefinePropertyValue(ctx, obj, const_name, variant_to_var(ctx, cls->constant_map.get(*const_key)), QuickJSBinder::PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, const_name);

}

// enumrations

for (const StringName *enum_key = cls->enum_map.next(NULL); enum_key; enum_key = cls->enum_map.next(enum_key)) {

const List<StringName> &consts = cls->enum_map.get(*enum_key);

JSValue enum_obj = JS_NewObject(ctx);

for (const List<StringName>::Element *E = consts.front(); E; E = E->next()) {

JSAtom const_name = get_atom(ctx, E->get());

JS_DefinePropertyValue(ctx, enum_obj, const_name, variant_to_var(ctx, cls->constant_map.get(E->get())), QuickJSBinder::PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, const_name);

}

JSAtom enum_name = get_atom(ctx, *enum_key);

JS_DefinePropertyValue(ctx, obj, enum_name, enum_obj, QuickJSBinder::PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, enum_name);

}

}

}

// global constants

HashMap<StringName, HashMap<StringName, int> > global_constants;

for (int i = 0; i < GlobalConstants::get_global_constant_count(); ++i) {

StringName enum_name = GlobalConstants::get_global_constant_enum(i);

const char *const_name = GlobalConstants::get_global_constant_name(i);

const int value = GlobalConstants::get_global_constant_value(i);

JSAtom js_const_name = JS_NewAtom(ctx, const_name);

JS_DefinePropertyValue(ctx, godot_object, js_const_name, JS_MKVAL(JS_TAG_INT, value), QuickJSBinder::PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, js_const_name);

if (HashMap<StringName, int> *consts = global_constants.getptr(enum_name)) {

consts->set(const_name, value);

} else {

HashMap<StringName, int> enum_;

enum_.set(const_name, value);

global_constants.set(enum_name, enum_);

}

}

// global numbers

GlobalNumberConstant consts[] = {

{ "PI", Math_PI },

{ "TAU", Math_TAU },

{ "NAN", Math_NAN },

{ "INF", Math_INF },

{ "E", Math_E },

{ "LN2", Math_LN2 },

{ "SQRT2", Math_SQRT2 },

{ "SQRT12", Math_SQRT12 },

};

for (int i = 0; i < sizeof(consts) / sizeof(GlobalNumberConstant); i++) {

const GlobalNumberConstant &c = consts[i];

JSAtom js_const_name = get_atom(ctx, c.name);

JS_DefinePropertyValue(ctx, godot_object, js_const_name, JS_NewFloat64(ctx, c.value), QuickJSBinder::PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, js_const_name);

}

// global enums

for (const StringName *enum_name = global_constants.next(NULL); enum_name; enum_name = global_constants.next(enum_name)) {

String enum_name_str = *enum_name;

if (enum_name_str.empty()) continue;

enum_name_str = enum_name_str.replace(".", "");

JSAtom atom_enum_name = get_atom(ctx, enum_name_str);

JSValue enum_object = JS_NewObject(ctx);

JS_DefinePropertyValue(ctx, godot_object, atom_enum_name, enum_object, QuickJSBinder::PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, atom_enum_name);

const HashMap<StringName, int> &enum_ = global_constants.get(*enum_name);

for (const StringName *const_name = enum_.next(NULL); const_name; const_name = enum_.next(const_name)) {

JSAtom js_const_name = get_atom(ctx, *const_name);

const int value = enum_.get(*const_name);

JS_DefinePropertyValue(ctx, enum_object, js_const_name, JS_MKVAL(JS_TAG_INT, value), QuickJSBinder::PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, js_const_name);

}

}

// buitin functions

for (int i = 0; i < Expression::FUNC_MAX; ++i) {

Expression::BuiltinFunc func = (Expression::BuiltinFunc)i;

String name = Expression::get_func_name(func);

JSValue js_func = JS_NewCFunctionMagic(ctx, godot_builtin_function, name.ascii().ptr(), 0, JS_CFUNC_generic_magic, i);

JSAtom atom = get_atom(ctx, name);

JS_DefinePropertyValue(ctx, godot_object, atom, js_func, QuickJSBinder::PROP_DEF_DEFAULT);

JS_FreeAtom(ctx, atom);

}

// godot.register_class

JSValue js_func_register_class = JS_NewCFunction(ctx, godot_register_class, "register_class", 2);

JS_DefinePropertyValueStr(ctx, godot_object, "register_class", js_func_register_class, PROP_DEF_DEFAULT);

// godot.register_signal

JSValue js_func_register_signal = JS_NewCFunction(ctx, godot_register_signal, "register_signal", 2);

JS_DefinePropertyValueStr(ctx, godot_object, "register_signal", js_func_register_signal, PROP_DEF_DEFAULT);

// godot.register_property

JSValue js_func_register_property = JS_NewCFunction(ctx, godot_register_property, "register_property", 3);

JS_DefinePropertyValueStr(ctx, godot_object, "register_property", js_func_register_property, PROP_DEF_DEFAULT);

// godot.set_script_tooled

JSValue js_func_set_tooled = JS_NewCFunctionMagic(ctx, godot_set_script_meta, "set_script_tooled", 2, JS_CFUNC_generic_magic, QuickJSBinder::SCRIPT_META_TOOLED);

JS_DefinePropertyValueStr(ctx, godot_object, "set_script_tooled", js_func_set_tooled, PROP_DEF_DEFAULT);

// godot.set_script_icon

JSValue js_set_script_icon = JS_NewCFunctionMagic(ctx, godot_set_script_meta, "set_script_icon", 2, JS_CFUNC_generic_magic, QuickJSBinder::SCRIPT_META_ICON);

JS_DefinePropertyValueStr(ctx, godot_object, "set_script_icon", js_set_script_icon, PROP_DEF_DEFAULT);

// godot.get_type

JSValue js_get_type = JS_NewCFunction(ctx, godot_get_type, "get_type", 1);

JS_DefinePropertyValueStr(ctx, godot_object, "get_type", js_get_type, PROP_DEF_DEFAULT);

// godot.load

JSValue js_func_load = JS_NewCFunction(ctx, godot_load, "load", 1);

JS_DefinePropertyValueStr(ctx, godot_object, "load", js_func_load, PROP_DEF_DEFAULT);

{

// godot.DEBUG_ENABLED

#ifdef DEBUG_ENABLED

JS_DefinePropertyValueStr(ctx, godot_object, "DEBUG_ENABLED", JS_TRUE, JS_PROP_ENUMERABLE);

#endif

// godot.TOOLS_ENABLED

#ifdef TOOLS_ENABLED

JS_DefinePropertyValueStr(ctx, godot_object, "TOOLS_ENABLED", JS_TRUE, JS_PROP_ENUMERABLE);

#endif

#ifdef DEBUG_METHODS_ENABLED

// godot.DEBUG_METHODS_ENABLED

JS_DefinePropertyValueStr(ctx, godot_object, "DEBUG_METHODS_ENABLED", JS_TRUE, JS_PROP_ENUMERABLE);

#endif

}

context_id = global_context_id++;

internal_godot_method_id = 0;

godot_allocator.js_malloc = QuickJSBinder::js_binder_malloc;

godot_allocator.js_free = QuickJSBinder::js_binder_free;

godot_allocator.js_realloc = QuickJSBinder::js_binder_realloc;

godot_allocator.js_malloc_usable_size = NULL;

godot_object_class = NULL;

if (class_remap.empty()) {

class_remap.insert(_File::get_class_static(), "File");

class_remap.insert(_Directory::get_class_static(), "Directory");

class_remap.insert(_Thread::get_class_static(), "");

class_remap.insert(_Mutex::get_class_static(), "");

class_remap.insert(_Semaphore::get_class_static(), "");

}

method_call_arguments = memnew_arr(Variant, MAX_ARGUMENT_COUNT);

method_call_argument_ptrs = memnew_arr(const Variant *, MAX_ARGUMENT_COUNT);

for (int i = 0; i < MAX_ARGUMENT_COUNT; ++i) {

method_call_argument_ptrs[i] = &(method_call_arguments[i]);

}

// create runtime and context for the binder

runtime = JS_NewRuntime2(&godot_allocator, this);

ctx = JS_NewContext(runtime);

JS_AddIntrinsicOperators(ctx);

JS_SetModuleLoaderFunc(runtime, /*js_module_resolve*/ NULL, js_module_loader, this);

JS_SetContextOpaque(ctx, this);

empty_function = JS_NewCFunction(ctx, js_empty_func, "virtual_fuction", 0);

// global = globalThis

global_object = JS_GetGlobalObject(ctx);

// globalThis.Operators.create

js_operators = JS_GetProperty(ctx, global_object, JS_ATOM_Operators);

js_operators_create = JS_GetPropertyStr(ctx, js_operators, "create");

// global.godot

godot_object = JS_NewObject(ctx);

js_key_godot_classid = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("cls"));

js_key_godot_exports = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("exports"));

js_key_godot_signals = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("signals"));

js_key_godot_tooled = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("tool"));

js_key_godot_icon_path = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("icon"));

JS_DefinePropertyValueStr(ctx, global_object, GODOT_OBJECT_NAME, godot_object, PROP_DEF_DEFAULT);

// godot.GodotOrigin

add_godot_origin();

// godot.Vector2 godot.Color ...

builtin_binder.initialize(ctx, this);

// godot.Object godot.Node godot.Theme ...

add_godot_classes();

// godot.print godot.sin ...

add_godot_globals();

// globalThis.Worker

add_global_worker();

// Other global properties

add_global_properties();

// globalThis.console

add_global_console();

// binding script

String script_binding_error;

if (OK != safe_eval_text(ECMAScriptBinder::BINDING_SCRIPT_CONTENT, "", script_binding_error)) {

CRASH_NOW_MSG("Execute script binding failed:\n" + script_binding_error);

}

godot_object_class = NULL;

builtin_binder.uninitialize();

// Free singletons

for (int i = 0; i < godot_singletons.size(); i++) {

ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, godot_singletons[i]);

if (bind) {

memdelete(bind);

JS_SetOpaque(godot_singletons[i], NULL);

}

JS_FreeValue(ctx, godot_singletons[i]);

}

// Free registered js classes

const String *key = ecma_classes.next(NULL);

while (key) {

const ECMAClassInfo &ecma_class = ecma_classes.get(*key);

free_ecmas_class(ecma_class);

key = ecma_classes.next(key);

}

ecma_classes.clear();

// Free frame callbacks

const int64_t *id = frame_callbacks.next(NULL);

while (id) {

const ECMAScriptGCHandler &func = frame_callbacks.get(*id);

JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.ecma_object);

JS_FreeValue(ctx, js_func);

id = frame_callbacks.next(id);

}

frame_callbacks.clear();

// modules

#if MODULE_HAS_REFCOUNT

const String *file = module_cache.next(NULL);

while (file) {

const ModuleCache &m = module_cache.get(*file);

if (m.module) {

JSValue val = JS_MKPTR(JS_TAG_MODULE, m.module);

JS_FreeValue(ctx, val);

}

file = module_cache.next(file);

}

#endif

module_cache.clear();

JS_FreeAtom(ctx, js_key_godot_classid);

JS_FreeAtom(ctx, js_key_godot_tooled);

JS_FreeAtom(ctx, js_key_godot_icon_path);

JS_FreeAtom(ctx, js_key_godot_exports);

JS_FreeAtom(ctx, js_key_godot_signals);

JS_FreeValue(ctx, js_operators);

JS_FreeValue(ctx, js_operators_create);

JS_FreeValue(ctx, empty_function);

JS_FreeValue(ctx, global_object);

JS_SetContextOpaque(ctx, NULL);

JS_FreeContext(ctx);

JS_FreeRuntime(runtime);

ctx = NULL;

runtime = NULL;

GLOBAL_LOCK_FUNCTION

const uint32_t *id = transfer_deopot.next(NULL);

while (id) {

ECMAScriptGCHandler *data = transfer_deopot.get(*id);

if (data->is_atomic_type()) {

Variant *ptr = static_cast<Variant *>(data->native_ptr);

memdelete(ptr);

memdelete(data);

} else {

if (data->flags & ECMAScriptGCHandler::FLAG_BUILTIN_CLASS) {

builtin_binder.builtin_finalizer(data);

} else if (data->is_reference()) {

memdelete(data->godot_reference);

}

}

id = transfer_deopot.next(id);

}

JSContext *ctx1;

int err;

for (;;) {

err = JS_ExecutePendingJob(JS_GetRuntime(ctx), &ctx1);

if (err <= 0) {

if (err < 0) {

ECMAscriptScriptError script_err;

JSValue e = JS_GetException(ctx1);