Variant *arguments;

const Variant **ptr;

GodotMethodArguments(int argc) {

if (argc) {

arguments = memnew_arr(Variant, argc);

ptr = memnew_arr(const Variant *, argc);

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

ptr[i] = &arguments[i];

}

} else {

arguments = NULL;

ptr = NULL;

}

}

~GodotMethodArguments() {

if (ptr) memdelete_arr(ptr);

if (arguments) memdelete_arr(arguments);

}

PoolStringArray args;

args.resize(argc);

QuickJSBinder *binder = get_context_binder(ctx);

JSValue object_to_json = JS_GetPropertyStr(ctx, binder->console_object, PROP_NAME_CONSOLE_LOG_OBJECT_TO_JSON);

bool to_json = js_to_bool(ctx, object_to_json);

JS_FreeValue(ctx, object_to_json);

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

int32_t tag = JS_VALUE_GET_TAG(argv[i]);

if (to_json && tag == JS_TAG_OBJECT && NULL == BINDING_DATA_FROM_JS(ctx, argv[i])) {

JSValue str = JS_JSONStringify(ctx, argv[i], JS_UNDEFINED, JS_UNDEFINED);

args.write()[i] = js_to_string(ctx, str);

JS_FreeValue(ctx, str);

} else {

size_t size;

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

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

JS_FreeCString(ctx, utf8);

}

}

ECMAScriptStackInfo stack_top;

List<ECMAScriptStackInfo> stacks;

String message = args.join(" ");

if (magic == CONSOLE_ERROR || magic == CONSOLE_TRACE || magic == CONSOLE_WARN) {

if (binder->get_stacks(stacks) == OK) {

stack_top = stacks.front()->get();

message += ENDL;

message += binder->get_backtrace_message(stacks);

}

}

switch (magic) {

case CONSOLE_ERROR:

_err_print_error(stack_top.function.utf8().get_data(), stack_top.file.utf8().get_data(), stack_top.line, message, ErrorHandlerType::ERR_HANDLER_ERROR);

break;

case CONSOLE_WARN:

_err_print_error(stack_top.function.utf8().get_data(), stack_top.file.utf8().get_data(), stack_top.line, message, ErrorHandlerType::ERR_HANDLER_WARNING);

break;

case CONSOLE_LOG:

case CONSOLE_TRACE:

default:

print_line(message);

break;

}

return JS_UNDEFINED;

JSValue console = JS_NewObject(ctx);

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

JSValue warn = JS_NewCFunctionMagic(ctx, console_functions, "warn", 0, JS_CFUNC_generic_magic, CONSOLE_WARN);

JSValue err = JS_NewCFunctionMagic(ctx, console_functions, "error", 0, JS_CFUNC_generic_magic, CONSOLE_ERROR);

JSValue trace = JS_NewCFunctionMagic(ctx, console_functions, "trace", 0, JS_CFUNC_generic_magic, CONSOLE_TRACE);

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, "error", err, PROP_DEF_DEFAULT);

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

console_object = JS_DupValue(ctx, console);

// 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"));

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

Object *obj = bind->get_godot_object();

MethodBind *mb = binder->godot_methods[method_id];

if (!mb->is_vararg()) {

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

}

GodotMethodArguments args(argc);

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

args.arguments[i] = var_to_variant(ctx, argv[i]);

}

Variant::CallError call_err;

Variant ret_val = mb->call(obj, args.ptr, argc, call_err);

JSValue ret = variant_to_var(ctx, ret_val);

#ifdef DEBUG_METHODS_ENABLED

String err_message;

switch (call_err.error) {

case Variant::CallError::CALL_ERROR_INVALID_ARGUMENT:

err_message = vformat("Argument of type '%s' is not assignable to parameter #%d of type '%s'", Variant::get_type_name(args.arguments[call_err.argument].get_type()), call_err.argument, Variant::get_type_name(call_err.expected));

break;

case Variant::CallError::CALL_ERROR_INVALID_METHOD:

err_message = vformat("Invalid method '%s' for type '%s'", mb->get_name(), obj->get_class_name());

break;

case Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:

err_message = vformat("Too few arguments for method '%s'", mb->get_name());

break;

case Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:

err_message = vformat("Too many arguments for method '%s'", mb->get_name());

break;

case Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL:

err_message = vformat("Attempt to call '%s' on a null instance.", mb->get_name());

break;

default:

break;

}

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

List<ECMAScriptStackInfo> stacks;

String stack_message;

if (binder->get_stacks(stacks) == OK) {

stack_message = binder->get_backtrace_message(stacks);

}

ERR_PRINT(obj->get_class() + "." + mb->get_name() + ENDL + err_message + ENDL + stack_message);

JS_FreeValue(ctx, ret);

ret = JS_ThrowTypeError(ctx, "%s", err_message.utf8().get_data());

}

#endif

return ret;

ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);

ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "Using indexed property without native binding data"));

ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "Using indexed property without native object caller"));

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

bool is_setter = argc > 0;

Object *obj = bind->get_godot_object();

const ClassDB::PropertySetGet *prop = binder->godot_object_indexed_properties[property_id];

MethodBind *mb = is_setter ? prop->_setptr : prop->_getptr;

GodotMethodArguments args(2);

args.arguments[0] = prop->index;

if (is_setter) {

args.arguments[1] = var_to_variant(ctx, argv[0]);

}

Variant::CallError call_err;

Variant ret_val = mb->call(obj, args.ptr, argc + 1, call_err);

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_NewInt64(ctx, int64_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;

if (obj == NULL) return JS_NULL;

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) {

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 (int 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().get_data(), variant_to_var(ctx, value));

}

return obj;

}

case Variant::NIL:

return JS_NULL;

default:

return QuickJSBuiltinBinder::new_object_from(ctx, p_var);

}

int64_t tag = JS_VALUE_GET_TAG(p_val);

switch (tag) {

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: {

if (JS_VALUE_GET_PTR(p_val) == NULL) {

return Variant();

}

int length = get_js_array_length(ctx, p_val);

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

Array arr;

arr.resize(length);

for (int 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 if (JS_IsFunction(ctx, p_val)) {

JSValue name = JS_GetProperty(ctx, p_val, JS_ATOM_name);

String ret = vformat("function %s() { ... }", js_to_string(ctx, name));

JS_FreeValue(ctx, name);

return ret;

} else { // Plain Object as Dictionary

List<void *> stack;

return js_to_dictionary(ctx, p_val, stack);

}

} break;

case JS_TAG_NULL:

case JS_TAG_UNDEFINED:

return Variant();

break;

default:

#ifdef JS_NAN_BOXING

if (tag > JS_TAG_FLOAT64 || tag < JS_TAG_FIRST) {

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

}

#endif

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().get_data());

}

QuickJSBinder *binder = get_context_binder(ctx);

GodotMethodArguments args(argc);

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

args.arguments[i] = var_to_variant(ctx, argv[i]);

}

Expression::exec_func(func, args.ptr, &ret, err, err_msg);

#ifdef DEBUG_METHODS_ENABLED

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

String func_name = Expression::get_func_name(func);

if (err_msg.empty()) {

switch (err.error) {

case Variant::CallError::CALL_ERROR_INVALID_ARGUMENT:

err_msg = vformat("Argument of type '%s' is not assignable to parameter #%d of type '%s'", Variant::get_type_name(args.arguments[err.argument].get_type()), err.argument, Variant::get_type_name(err.expected));

break;

case Variant::CallError::CALL_ERROR_INVALID_METHOD:

err_msg = vformat("Invalid builtin function", func_name);

break;

case Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:

err_msg = vformat("Too few arguments builtin function", func_name);

break;

case Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:

err_msg = vformat("Too many arguments for builtin function", func_name);

break;

default:

break;

}

}

}

#endif

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().get_data(), err_msg.utf8().get_data());

}

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 == p_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;

JSValue error_constructor = JS_GetProperty(ctx, global_object, JS_ATOM_Error);

JSValue error = JS_CallConstructor(ctx, error_constructor, 0, NULL);

JSValue stack = JS_GetProperty(ctx, error, JS_ATOM_stack);

String stack_text = js_to_string(ctx, stack);

Vector<String> raw_stacks = stack_text.split("\n", false);

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

String line_text = raw_stacks[i].strip_edges();

if (line_text.empty()) continue;

ECMAScriptStackInfo s;

int colon = line_text.find_last(":");

int bracket = line_text.find_last("(");

s.line = line_text.substr(colon + 1, line_text.length() - colon - 2).to_int();

s.file = line_text.substr(bracket + 1, colon - bracket - 1);

s.function = line_text.substr(3, bracket - 4);

r_stacks.push_back(s);

}

JS_FreeValue(ctx, stack);

JS_FreeValue(ctx, error);

JS_FreeValue(ctx, error_constructor);

return OK;

String message;

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

message += " ";

message += vformat("at %s (%s:%d)", E->get().function, E->get().file, E->get().line);

if (E != stacks.back()) {

message += ENDL;

}

}

return message;

Dictionary dict;

Set<String> keys;

get_own_property_names(ctx, p_val, &keys);

stack.push_back(JS_VALUE_GET_PTR(p_val));

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

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

Variant val;

if (JS_IsObject(v)) {

void *ptr = JS_VALUE_GET_PTR(v);

if (stack.find(ptr)) {

union {

const void *p;

uint64_t i;

} u;

u.p = ptr;

ERR_PRINT(vformat("Property '%s' circular reference to 0x%X", E->get(), u.i));

JS_FreeValue(ctx, v);

continue;

} else {

stack.push_back(ptr);

val = var_to_variant(ctx, v);

stack.pop_back();

}

} else {

val = var_to_variant(ctx, v);

}

dict[E->get()] = val;

JS_FreeValue(ctx, v);

}

stack.pop_back();

return dict;

String name = p_key;

CharString name_str = name.ascii();

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

return atom;

String str = var_to_variant(ctx, this_val);

CharString ascii = str.ascii();

return JS_NewStringLen(ctx, ascii.get_data(), 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);

#ifdef DEBUG_METHODS_ENABLED

ERR_FAIL_COND_V(argc < 1 || !JS_IsNumber(argv[0]), JS_ThrowTypeError(ctx, "number expected for %s.%s", GODOT_OBJECT_NAME, "instance_from_id"));

#endif

ObjectID id = js_to_uint64(ctx, argv[0]);

Object *obj = ObjectDB::get_instance(id);

return variant_to_var(ctx, obj);

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);

if (const String *ptr = resolve_path_cache.getptr(file)) {

return *ptr;

}

String path = file;

if (FileAccess::exists(path)) return path;

// add extensions to try

String extension = file.get_extension();

List<String> extensions;

ECMAScriptLanguage::get_singleton()->get_recognized_extensions(&extensions);

if (extensions.find(extension) == NULL) {

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

path = file + "." + E->get();

if (FileAccess::exists(path)) {

return path;

}

}

}

// try index file under the folder

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

path = file + "/index." + E->get();

if (FileAccess::exists(path)) {

return path;

}

}

return "";

if (NULL != compiling_modules.find(p_filename)) {

String chain;

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

chain += E->get();

if (E->next() != NULL) {

chain += " <- ";

}

}

ERR_FAIL_V_MSG(ModuleCache(), vformat("Cyclic module import detected:\r\n %s", chain));

}

ModuleCache module;

module.flags = 0;

module.module = NULL;

module.hash = p_code.hash();

CharString code = p_code.utf8();

CharString filename = p_filename.utf8();

const char *cfilename = filename.get_data();

const char *cfilesource = code.get_data();

compiling_modules.push_back(p_filename);

JSValue func = JS_Eval(ctx, cfilesource, code.length(), cfilename, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);

compiling_modules.pop_back();

if (!JS_IsException(func)) {

module.flags = MODULE_FLAG_SCRIPT;

module.module = static_cast<JSModuleDef *>(JS_VALUE_GET_PTR(func));

module.res_value = JS_UNDEFINED;

} else {

JSValue e = JS_GetException(ctx);

dump_exception(ctx, e, r_error);

JS_Throw(ctx, e);

}

return module;

if (p_module->flags & MODULE_FLAG_EVALUATED)

return OK;

JSValue module = JS_MKPTR(JS_TAG_MODULE, p_module->module);

if (JS_IsException(module)) {

JSValue e = JS_GetException(ctx);

dump_exception(ctx, e, r_error);

JS_Throw(ctx, e);

return ERR_PARSE_ERROR;

}

if (!(p_module->flags & MODULE_FLAG_EVALUATED)) {

JSValue ret = JS_EvalFunction(ctx, module);

if (JS_IsException(ret)) {

JSValue e = JS_GetException(ctx);

dump_exception(ctx, e, r_error);

JS_Throw(ctx, e);

return ERR_PARSE_ERROR;

} else {

p_module->flags |= MODULE_FLAG_EVALUATED;

}

JS_FreeValue(ctx, ret);

}

return OK;

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 (strcmp(data.jsclass.class_name, "") == 0) {

return 0;

}

} else {

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

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

}

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.get_data(), mb->get_argument_count(), JS_CFUNC_generic_magic, internal_godot_method_id);

JS_DefinePropertyValueStr(ctx, data.prototype, name.get_data(), 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 = JS_UNDEFINED;

JSValue getter = JS_UNDEFINED;

if (prop.index >= 0) {

int size = godot_object_indexed_properties.size();

if (size <= internal_godot_indexed_property_id) {

godot_object_indexed_properties.resize(size + 128);

}

godot_object_indexed_properties.write[internal_godot_indexed_property_id] = &prop;

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

getter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_indexed_property, name.get_data(), 0, JS_CFUNC_generic_magic, internal_godot_indexed_property_id);

setter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_indexed_property, name.get_data(), 1, JS_CFUNC_generic_magic, internal_godot_indexed_property_id);

++internal_godot_indexed_property_id;

} else {

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

setter = E->get();

JS_DupValue(ctx, setter);

} else if (MethodBind *mb = prop._setptr) {

if (godot_methods.size() >= internal_godot_method_id) {

godot_methods.resize(godot_methods.size() + 1);

}

godot_methods.write[internal_godot_method_id] = mb;

String setter_name = prop.setter;

setter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_method, setter_name.ascii().get_data(), mb->get_argument_count(), JS_CFUNC_generic_magic, internal_godot_method_id);

++internal_godot_method_id;

}

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

getter = E->get();

JS_DupValue(ctx, getter);

} else if (MethodBind *mb = prop._getptr) {

if (godot_methods.size() >= internal_godot_method_id) {

godot_methods.resize(godot_methods.size() + 1);

}

godot_methods.write[internal_godot_method_id] = mb;

String getter_name = prop.getter;

getter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_method, getter_name.ascii().get_data(), mb->get_argument_count(), JS_CFUNC_generic_magic, internal_godot_method_id);

++internal_godot_method_id;

}

}

JSAtom atom = get_atom(ctx, prop_name);

JS_DefinePropertyGetSet(ctx, data.prototype, atom, getter, setter, 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.get_data();

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);