void MonoEmbedding::Initialize()
{
// Construct the absolute file path to MonoEmbedding.exe assuming
// it is located next to edge.node
Dl_info dlinfo;
char fullPath[PATH_MAX];
dladdr((void*)&MonoEmbedding::Initialize, &dlinfo);
strcpy(fullPath, dlinfo.dli_fname);
strcpy(fullPath, dirname(fullPath));
strcat(fullPath, "/MonoEmbedding.exe");
mono_jit_init (fullPath);
assembly = mono_domain_assembly_open (mono_domain_get(), fullPath);
MonoClass* klass = mono_class_from_name(mono_assembly_get_image(assembly), "", "MonoEmbedding");
MonoMethod* main = mono_class_get_method_from_name(klass, "Main", -1);
MonoException* exc;
MonoArray* args = mono_array_new(mono_domain_get(), mono_get_string_class(), 0);
mono_runtime_exec_main(main, args, (MonoObject**)&exc);
mono_add_internal_call("ClrFuncInvokeContext::CompleteOnV8ThreadAsynchronousICall", (const void*)&ClrFuncInvokeContext::CompleteOnV8ThreadAsynchronous);
mono_add_internal_call("ClrFuncInvokeContext::CompleteOnCLRThreadICall", (const void*)&ClrFuncInvokeContext::CompleteOnCLRThread);
mono_add_internal_call("NodejsFuncInvokeContext::CallFuncOnV8ThreadInternal", (const void*)&NodejsFuncInvokeContext::CallFuncOnV8Thread);
mono_add_internal_call("NodejsFunc::ExecuteActionOnV8Thread", (const void*)&NodejsFunc::ExecuteActionOnV8Thread);
mono_add_internal_call("NodejsFunc::Release", (const void*)&NodejsFunc::Release);
}
int main() {
/*
TODO: using abs paths just to test this shit.
*/
// Set path where managed assemblies live.
mono_set_assemblies_path("C:\\Users\\Niko\\Source\\Repos\\SaNi\\vs2013\\sanimono\\SaNi\\bin\\Debug");
// Set Mono library and configuration paths.
mono_set_dirs("C:\\Program Files (x86)\\Mono\\lib", "C:\\Program Files (x86)\\Mono\\etc");
// Our application assembly that contains
// the code we are going to run.
domain = mono_jit_init_version("SaNi", "v4.0.30319");
// Our domain in which the code will be
// executed.
MonoAssembly* assembly = mono_domain_assembly_open(domain, "C:\\Users\\Niko\\Source\\Repos\\SaNi\\vs2013\\sanimono\\SaNi\\bin\\Debug\\SaNi.exe");
if (!assembly) throw std::runtime_error("could not load the given Mono assembly");
mono_add_internal_call("SaNi.Utils::Print(string)", (void*)print);
mono_add_internal_call("SaNi.Utils::GetString()", (void*)getString);
const auto argc = 6;
char* argv[argc] = { "HELLO", "WORLD", "FROM", "THE", "F*****G", "MONO" };
mono_jit_exec(domain, assembly, argc, argv);
// Clean mono.
mono_jit_cleanup(domain);
return 0;
}
void GodotSharpExport::register_internal_calls() {
static bool registered = false;
ERR_FAIL_COND(registered);
registered = true;
mono_add_internal_call("GodotSharpTools.Editor.GodotSharpExport::GetTemplatesDir", (void *)godot_icall_GodotSharpExport_GetTemplatesDir);
mono_add_internal_call("GodotSharpTools.Editor.GodotSharpExport::GetDataDirName", (void *)godot_icall_GodotSharpExport_GetDataDirName);
}
void ConHost_AddInternalCalls()
{
mono_add_internal_call("CitizenFX.UI.ConsoleImpl::GetDesiredBufferSize", ConHostI_GetDesiredBufferSizeCall);
mono_add_internal_call("CitizenFX.UI.ConsoleImpl::GetKeyInternal", ConHostI_GetKeyCall);
mono_add_internal_call("CitizenFX.UI.ConsoleImpl::SetBuffer", ConHostI_SetBufferCall);
mono_add_internal_call("CitizenFX.UI.ConsoleImpl::SetCursorPos", ConHostI_SetCursorPosCall);
mono_add_internal_call("CitizenFX.UI.ConsoleImpl::InvokeHostFunction", ConHostI_InvokeHostFunction);
}
void
mono_tasklets_init(void)
{
mono_add_internal_call ("Mono.Tasklets.Continuation::alloc", continuation_alloc);
mono_add_internal_call ("Mono.Tasklets.Continuation::free", continuation_free);
mono_add_internal_call ("Mono.Tasklets.Continuation::mark", continuation_mark_frame);
mono_add_internal_call ("Mono.Tasklets.Continuation::store", continuation_store);
mono_add_internal_call ("Mono.Tasklets.Continuation::restore", continuation_restore);
}
void
mono_tasklets_init (void)
{
InitializeCriticalSection (&tasklets_mutex);
mono_add_internal_call ("Mono.Tasklets.Continuation::alloc", continuation_alloc);
mono_add_internal_call ("Mono.Tasklets.Continuation::free", continuation_free);
mono_add_internal_call ("Mono.Tasklets.Continuation::mark", continuation_mark_frame);
mono_add_internal_call ("Mono.Tasklets.Continuation::store", continuation_store);
mono_add_internal_call ("Mono.Tasklets.Continuation::restore", continuation_restore);
}
int sr_mono_load_class_hdr()
{
int i;
for(i=0; _sr_M_export_hdr[i].name!=NULL; i++)
mono_add_internal_call(_sr_M_export_hdr[i].name, _sr_M_export_hdr[i].method);
return 0;
}
void CScriptSystem::RegisterMethodBinding(const void *method, const char *fullMethodName)
{
if(!IsInitialized())
m_methodBindings.insert(TMethodBindings::value_type(method, fullMethodName));
else
mono_add_internal_call(fullMethodName, method);
}
void godot_register_string_icalls() {
mono_add_internal_call("Godot.String::godot_icall_String_md5_buffer", (void *)godot_icall_String_md5_buffer);
mono_add_internal_call("Godot.String::godot_icall_String_md5_text", (void *)godot_icall_String_md5_text);
mono_add_internal_call("Godot.String::godot_icall_String_rfind", (void *)godot_icall_String_rfind);
mono_add_internal_call("Godot.String::godot_icall_String_rfindn", (void *)godot_icall_String_rfindn);
mono_add_internal_call("Godot.String::godot_icall_String_sha256_buffer", (void *)godot_icall_String_sha256_buffer);
mono_add_internal_call("Godot.String::godot_icall_String_sha256_text", (void *)godot_icall_String_sha256_text);
}
/**
* This program must be run like this: ./test MonoEmbedded.exe
* (it requires one argument, even when it is not going to be used because I do not know what
* parameters to use in mono_jit_exec method, it crashes with NULL value :/)
*/
int main (int argc, char *argv[])
{
/*
* Load the default Mono configuration file, this is needed
* if you are planning on using the dllmaps defined on the
* system configuration
*/
mono_config_parse (NULL);
/*
* mono_jit_init() creates a domain: each assembly is
* loaded and run in a MonoDomain.
*/
MonoDomain *domain = mono_jit_init ("../MonoEmbedded/bin/Debug/MonoEmbedded.exe");
/*
* Optionally, add an internal call that your startup.exe
* code can call, this will bridge startup.exe to Mono
*/
mono_add_internal_call ("MonoEmbedded.MainClass::Print", (void *)p_Print);
/*
* Open the executable, and run the Main method declared
* in the executable
*/
MonoAssembly *assembly = mono_domain_assembly_open (domain, "../MonoEmbedded/bin/Debug/MonoEmbedded.exe");
if (!assembly) {
exit (2);
}
/*
* mono_jit_exec() will run the Main() method in the assembly.
* The return value needs to be looked up from
* System.Environment.ExitCode.
*/
mono_jit_exec (domain, assembly, argc - 1, argv + 1);
return 0;
}
int
main(int argc, char* argv[]) {
MonoDomain *domain;
const char *file;
int retval;
puts("Ola");
if (argc < 2){
fprintf (stderr, "Please provide an assembly to load\n");
return 1;
}
file = argv [1];
/*
* Load the default Mono configuration file, this is needed
* if you are planning on using the dllmaps defined on the
* system configuration
*/
mono_config_parse (NULL);
/*
* mono_jit_init() creates a domain: each assembly is
* loaded and run in a MonoDomain.
*/
domain = mono_jit_init (file);
/*
* We add our special internal call, so that C# code
* can call us back.
*/
mono_add_internal_call ("MonoEmbed::gimme", gimme);
main_function (domain, file, argc - 1, argv + 1);
retval = mono_environment_exitcode_get ();
mono_jit_cleanup (domain);
getch();
return retval;
}
int
main(int argc, char* argv[]) {
MonoDomain *domain;
const char *file;
int retval;
MainThreadArgs main_args;
if (argc < 2){
fprintf (stderr, "Please provide an assembly to load\n");
return 1;
}
file = argv [1];
/*
* mono_jit_init() creates a domain: each assembly is
* loaded and run in a MonoDomain.
*/
domain = mono_interp_init (file);
/*
* We add our special internal call, so that C# code
* can call us back.
*/
mono_add_internal_call ("MonoEmbed::gimme", gimme);
main_args.domain=domain;
main_args.file=file;
main_args.argc=argc-1;
main_args.argv=argv+1;
mono_runtime_exec_managed_code (domain, main_thread_handler,
&main_args);
retval=mono_environment_exitcode_get ();
mono_interp_cleanup (domain);
return retval;
}
void Application::InitializeMono()
{
//this will override the internal assembly search logic.
//do it in case you package mono in a different structure
//mono_set_assemblies_path(dllDir.c_str());
mono_config_parse(NULL);
// initialize the root domain which will hold corlib and will always be alive
domain = mono_jit_init_version("CCubed Root Domain", "v4.0.30319");
// soft debugger needs this
mono_thread_set_main(mono_thread_current());
// add icalls
mono_add_internal_call("EmbedThings.EntryPoint::reload", reload);
// run the c# bits
Run();
// we're exiting the whole thing, cleanup
mono_jit_cleanup(mono_domain_get());
}
void godot_register_collections_icalls() {
mono_add_internal_call("Godot.Array::godot_icall_Array_Ctor", (void *)godot_icall_Array_Ctor);
mono_add_internal_call("Godot.Array::godot_icall_Array_Dtor", (void *)godot_icall_Array_Dtor);
mono_add_internal_call("Godot.Array::godot_icall_Array_At", (void *)godot_icall_Array_At);
mono_add_internal_call("Godot.Array::godot_icall_Array_SetAt", (void *)godot_icall_Array_SetAt);
mono_add_internal_call("Godot.Array::godot_icall_Array_Count", (void *)godot_icall_Array_Count);
mono_add_internal_call("Godot.Array::godot_icall_Array_Add", (void *)godot_icall_Array_Add);
mono_add_internal_call("Godot.Array::godot_icall_Array_Clear", (void *)godot_icall_Array_Clear);
mono_add_internal_call("Godot.Array::godot_icall_Array_Contains", (void *)godot_icall_Array_Contains);
mono_add_internal_call("Godot.Array::godot_icall_Array_CopyTo", (void *)godot_icall_Array_CopyTo);
mono_add_internal_call("Godot.Array::godot_icall_Array_IndexOf", (void *)godot_icall_Array_IndexOf);
mono_add_internal_call("Godot.Array::godot_icall_Array_Insert", (void *)godot_icall_Array_Insert);
mono_add_internal_call("Godot.Array::godot_icall_Array_Remove", (void *)godot_icall_Array_Remove);
mono_add_internal_call("Godot.Array::godot_icall_Array_RemoveAt", (void *)godot_icall_Array_RemoveAt);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_Ctor", (void *)godot_icall_Dictionary_Ctor);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_Dtor", (void *)godot_icall_Dictionary_Dtor);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_GetValue", (void *)godot_icall_Dictionary_GetValue);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_SetValue", (void *)godot_icall_Dictionary_SetValue);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_Keys", (void *)godot_icall_Dictionary_Keys);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_Values", (void *)godot_icall_Dictionary_Values);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_Count", (void *)godot_icall_Dictionary_Count);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_Add", (void *)godot_icall_Dictionary_Add);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_Clear", (void *)godot_icall_Dictionary_Clear);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_Contains", (void *)godot_icall_Dictionary_Contains);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_ContainsKey", (void *)godot_icall_Dictionary_ContainsKey);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_RemoveKey", (void *)godot_icall_Dictionary_RemoveKey);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_Remove", (void *)godot_icall_Dictionary_Remove);
mono_add_internal_call("Godot.Dictionary::godot_icall_Dictionary_TryGetValue", (void *)godot_icall_Dictionary_TryGetValue);
}
static void InitMono()
{
std::string citizenClrPath = MakeRelativeNarrowPath("citizen/clr2/lib/");
std::string citizenCfgPath = MakeRelativeNarrowPath("citizen/clr2/cfg/");
mono_set_dirs(citizenClrPath.c_str(), citizenCfgPath.c_str());
#ifdef _WIN32
std::wstring citizenClrLibPath = MakeRelativeCitPath(L"citizen/clr2/lib/mono/4.5/");
SetEnvironmentVariable(L"MONO_PATH", citizenClrLibPath.c_str());
mono_set_crash_chaining(true);
#else
std::string citizenClrLibPath = MakeRelativeNarrowPath("citizen/clr2/lib/mono/4.5/");
putenv(const_cast<char*>(va("MONO_PATH=%s", citizenClrLibPath)));
#endif
mono_assembly_setrootdir(citizenClrPath.c_str());
putenv("MONO_DEBUG=casts");
#ifndef IS_FXSERVER
mono_security_enable_core_clr();
mono_security_core_clr_set_options((MonoSecurityCoreCLROptions)(MONO_SECURITY_CORE_CLR_OPTIONS_RELAX_DELEGATE | MONO_SECURITY_CORE_CLR_OPTIONS_RELAX_REFLECTION));
mono_security_set_core_clr_platform_callback(CoreClrCallback);
#endif
char* args[1];
#ifdef _WIN32
args[0] = "--soft-breakpoints";
#else
args[0] = "--use-fallback-tls";
#endif
mono_jit_parse_options(1, args);
mono_debug_init(MONO_DEBUG_FORMAT_MONO);
g_rootDomain = mono_jit_init_version("Citizen", "v4.0.30319");
mono_domain_set_config(g_rootDomain, ".", "cfx.config");
mono_install_unhandled_exception_hook([] (MonoObject* exc, void*)
{
OutputExceptionDetails(exc);
}, nullptr);
mono_set_crash_chaining(true);
mono_add_internal_call("CitizenFX.Core.GameInterface::PrintLog", reinterpret_cast<void*>(GI_PrintLogCall));
mono_add_internal_call("CitizenFX.Core.GameInterface::fwFree", reinterpret_cast<void*>(fwFree));
std::string platformPath = MakeRelativeNarrowPath("citizen/clr2/lib/mono/4.5/CitizenFX.Core.dll");
auto scriptManagerAssembly = mono_domain_assembly_open(g_rootDomain, platformPath.c_str());
if (!scriptManagerAssembly)
{
FatalError("Could not load CitizenFX.Core.dll.\n");
}
auto scriptManagerImage = mono_assembly_get_image(scriptManagerAssembly);
bool methodSearchSuccess = true;
MonoMethodDesc* description;
#define method_search(name, method) description = mono_method_desc_new(name, 1); \
method = mono_method_desc_search_in_image(description, scriptManagerImage); \
mono_method_desc_free(description); \
methodSearchSuccess = methodSearchSuccess && method != NULL
MonoMethod* rtInitMethod;
method_search("CitizenFX.Core.RuntimeManager:Initialize", rtInitMethod);
method_search("CitizenFX.Core.RuntimeManager:GetImplementedClasses", g_getImplementsMethod);
method_search("CitizenFX.Core.RuntimeManager:CreateObjectInstance", g_createObjectMethod);
if (!methodSearchSuccess)
{
FatalError("Couldn't find one or more CitizenFX.Core methods.\n");
}
MonoObject* exc = nullptr;
mono_runtime_invoke(rtInitMethod, nullptr, nullptr, &exc);
if (exc)
{
OutputExceptionDetails(exc);
return;
}
}
JNIEXPORT jboolean JNICALL Java_com_koushikdutta_monojavabridge_MonoBridge_initializeMono
(JNIEnv *env, jclass clazz, jstring debuggerAgentOptions)
{
// setenv("HOME", "/data/data/com.koushikdutta.twitter/", 1);
#ifdef PLATFORM_ANDROID
if (debuggerAgentOptions != NULL)
{
LOGI("Debugger enabled...");
int length = (*env)->GetStringLength(env, debuggerAgentOptions);
const jbyte *str = (*env)->GetStringUTFChars(env, debuggerAgentOptions, NULL);
char *copy = (char*)malloc(length + 1);
copy[length] = NULL;
memcpy(copy, str, length);
mono_debugger_agent_parse_options(copy);
free(copy);
(*env)->ReleaseStringUTFChars(env, debuggerAgentOptions, str);
mono_debug_init (MONO_DEBUG_FORMAT_MONO);
}
#endif
//guint32 opt = mono_parse_default_optimizations(NULL);
//mono_set_defaults (1, opt);
//mono_trace_parse_options ("");
setenv("MONO_PATH", "/data/data/com.koushikdutta.mono/", 0);
#ifdef PLATFORM_ANDROID
LOGI("mono_jit_init...");
#endif
g_Domain = mono_jit_init (MONOJAVABRIDGE_DLL);
#ifdef PLATFORM_ANDROID
LOGI("mono_domain_assembly_open...", NULL);
#endif
g_Assembly = mono_domain_assembly_open (g_Domain, MONOJAVABRIDGE_DLL);
if (!g_Assembly)
{
printf("Unable to load MonoJavaBridge.dll.");
return FALSE;
}
mono_add_internal_call("MonoJavaBridge.JavaBridge::mono_object_to_pointer(object)", mono_objectpointer_conversion);
mono_add_internal_call("MonoJavaBridge.JavaBridge::mono_pointer_to_object(intptr)", mono_objectpointer_conversion);
mono_add_internal_call("MonoJavaBridge.JavaBridge::log(intptr)", logcat_print);
MonoImage *image = mono_assembly_get_image(g_Assembly);
MonoMethodDesc* desc = mono_method_desc_new ("MonoJavaBridge.JavaBridge:Initialize(intptr)", 1);
MonoMethod* method = mono_method_desc_search_in_image (desc, image);
mono_method_desc_free(desc);
pointer args[1];
args[0] = &g_JavaVM;
mono_runtime_invoke(method, NULL, args, NULL);
desc = mono_method_desc_new ("MonoJavaBridge.JavaBridge:Link(intptr,intptr,intptr,intptr)", 1);
g_Link = mono_method_desc_search_in_image (desc, image);
mono_method_desc_free(desc);
desc = mono_method_desc_new ("MonoJavaBridge.JavaBridge:LoadAssembly(intptr)", 1);
g_LoadAssembly = mono_method_desc_search_in_image (desc, image);
mono_method_desc_free(desc);
return TRUE;
}
void ml_init_internal_calls(void)
{
mono_add_internal_call("Purple.Debug::_debug", purple_debug_glue);
mono_add_internal_call("Purple.Signal::_connect", purple_signal_connect_glue);
mono_add_internal_call("Purple.BuddyList::_get_handle", purple_blist_get_handle_glue);
}
void GodotSharpBuilds::_register_internal_calls() {
mono_add_internal_call("GodotSharpTools.Build.BuildSystem::godot_icall_BuildInstance_ExitCallback", (void *)godot_icall_BuildInstance_ExitCallback);
mono_add_internal_call("GodotSharpTools.Build.BuildInstance::godot_icall_BuildInstance_get_MSBuildInfo", (void *)godot_icall_BuildInstance_get_MSBuildInfo);
}
void
mono_init_virt ()
{
const char *error;
#ifndef MONO_AGENT
char * cfg_mono_root_path;
char * cfg_mono_cfg_dir;
char * cfg_mono_path;
char * cfg_mono_trace;
/*g_log_set_always_fatal (G_LOG_LEVEL_ERROR);
g_log_set_fatal_mask (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR);*/
#ifndef VIRT_MINT
if (virtuoso_cfg_getstring ("Mono", "MONO_TRACE", &cfg_mono_trace) != -1)
mono_jit_trace_calls = strcmp (cfg_mono_trace, "On") ? FALSE : TRUE;
#endif
if (virtuoso_cfg_getstring ("Mono", "MONO_PATH", &cfg_mono_path) != -1)
setenv ("MONO_PATH", cfg_mono_path, 1);
if (virtuoso_cfg_getstring ("Mono", "MONO_ROOT", &cfg_mono_root_path) != -1)
setenv ("MONO_ROOT", cfg_mono_root_path, 1);
if (virtuoso_cfg_getstring ("Mono", "MONO_CFG_DIR", &cfg_mono_cfg_dir) != -1)
setenv ("MONO_CFG_DIR", cfg_mono_cfg_dir, 1);
if (virtuoso_cfg_getstring ("Mono", "virtclr.dll", &VIRTCLR_NAME) == -1)
VIRTCLR_NAME = "virtclr.dll";
#endif
#ifdef WIN32
/* mono initialization on win32 has to be done sooner than later */
#ifdef VIRT_MINT
virtuoso_domain = mono_interp_init ("virtuoso");
#else
virtuoso_domain = mono_jit_init ("virtuoso");
#endif
if (cfg_mono_root_path)
mono_assembly_setrootdir (cfg_mono_root_path);
#endif
#ifndef VIRT_MINT
mono_jit_trace_calls = FALSE;
#endif
{
char *path = getenv ("MONO_ROOT");
if (path)
mono_assembly_setrootdir (path);
}
/* mono_debug_init (1); */
#ifndef WIN32
setlocale(LC_ALL, "");
#endif
g_log_set_always_fatal (G_LOG_LEVEL_ERROR);
g_log_set_fatal_mask (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR);
g_set_printerr_handler (dummy_print);
#ifndef WIN32
#ifdef VIRT_MINT
virtuoso_domain = mono_interp_init ("virtuoso");
#else
virtuoso_domain = mono_jit_init ("virtuoso");
#endif
mono_config_parse (NULL);
#ifdef OLD_KIT
if (NULL != (error = mono_verify_corlib ()))
#elif !defined (OLD_KIT_1_1_5)
if (NULL != (error = mono_check_corlib_version ()))
#endif
{
log_error ("Mono Corlib not in sync with this runtime: %s", error);
exit (-1);
}
#ifndef VIRT_MINT
#ifdef OLD_KIT_1_1_5
mono_thread_attach_aborted_cb = virt_mono_throw_unhandled_exception;
#else
mono_thread_set_attach_aborted_cb (virt_mono_throw_unhandled_exception);
#endif
#endif
#endif
mono_add_internal_call ("VInvoke::LoadAssemblyFromVirtuoso(string)", ves_icall_VInvoke_LoadAssemblyFromVirtuoso);
#ifndef MONO_AGENT
mono_set_port ();
#endif
#ifndef MONO_AGENT
#ifdef OLD_KIT_1_1_4
log_debug ("Mono config path [%s]", mono_cfg_dir);
#else
log_debug ("Mono config path [%s]", mono_get_config_dir ());
#endif
#endif
#ifndef WIN32
setlocale (LC_ALL, "C");
#endif
#ifndef OLD_KIT_1_1_5
mono_thread_manage ();
mono_thread_set_main (mono_thread_current());
#endif
}
void godot_register_rid_icalls() {
mono_add_internal_call("Godot.RID::godot_icall_RID_Ctor", (void *)godot_icall_RID_Ctor);
mono_add_internal_call("Godot.RID::godot_icall_RID_Dtor", (void *)godot_icall_RID_Dtor);
mono_add_internal_call("Godot.RID::godot_icall_RID_get_id", (void *)godot_icall_RID_get_id);
}
void mioAddMethod(const char *name, void *addr)
{
mono_add_internal_call(name, addr);
}
void godot_register_object_icalls() {
mono_add_internal_call("Godot.Object::godot_icall_Object_Ctor", (void *)godot_icall_Object_Ctor);
mono_add_internal_call("Godot.Object::godot_icall_Object_Disposed", (void *)godot_icall_Object_Disposed);
mono_add_internal_call("Godot.Object::godot_icall_Reference_Disposed", (void *)godot_icall_Reference_Disposed);
mono_add_internal_call("Godot.Object::godot_icall_Object_ClassDB_get_method", (void *)godot_icall_Object_ClassDB_get_method);
mono_add_internal_call("Godot.Object::godot_icall_Object_ToString", (void *)godot_icall_Object_ToString);
mono_add_internal_call("Godot.Object::godot_icall_Object_weakref", (void *)godot_icall_Object_weakref);
mono_add_internal_call("Godot.SignalAwaiter::godot_icall_SignalAwaiter_connect", (void *)godot_icall_SignalAwaiter_connect);
mono_add_internal_call("Godot.DynamicGodotObject::godot_icall_DynamicGodotObject_SetMemberList", (void *)godot_icall_DynamicGodotObject_SetMemberList);
mono_add_internal_call("Godot.DynamicGodotObject::godot_icall_DynamicGodotObject_InvokeMember", (void *)godot_icall_DynamicGodotObject_InvokeMember);
mono_add_internal_call("Godot.DynamicGodotObject::godot_icall_DynamicGodotObject_GetMember", (void *)godot_icall_DynamicGodotObject_GetMember);
mono_add_internal_call("Godot.DynamicGodotObject::godot_icall_DynamicGodotObject_SetMember", (void *)godot_icall_DynamicGodotObject_SetMember);
}
void try_mono() {
MonoDomain *domain;
MonoAssembly *ma;
MonoImage *mi;
MonoClass *mc;
MonoMethodDesc *mmd;
MonoMethod *mm;
MonoObject *mo;
FILE *mscorlib;
char *corlib_data = NULL;
void *args [2];
static int x = 123000;
args [0] = &x;
args [1] = "hello world";
#if defined(__native_client__)
mscorlib = fopen("mscorlib.dll", "r");
if (NULL != mscorlib) {
size_t size;
struct stat st;
if (0 == stat("mscorlib.dll", &st)) {
size = st.st_size;
printf("reading mscorlib.dll, size %ld\n", size);
corlib_data = malloc(size);
if (corlib_data != NULL) {
while (fread(corlib_data, 1, size, mscorlib) != 0) ;
if (!ferror(mscorlib)) {
mono_set_corlib_data(corlib_data, size);
} else {
perror("error reading mscorlib.dll");
free(corlib_data);
corlib_data = NULL;
}
} else {
perror("Could not allocate memory");
}
} else {
perror("stat error");
}
fclose(mscorlib);
}
#endif
#ifdef AOT_VERSION
printf("address of mono_aot_module_mscorlib_info: %p\n", mono_aot_module_mscorlib_info);
printf("address of mono_aot_module_hw_info: %p\n", mono_aot_module_hw_info);
// mono_jit_set_aot_only(TRUE) should be enabled now.
// if not enabled, I suspect we're still jitting...
mono_jit_set_aot_only(TRUE);
mono_aot_register_module(mono_aot_module_mscorlib_info);
mono_aot_register_module(mono_aot_module_hw_info);
#endif
mono_debug_init(MONO_DEBUG_FORMAT_MONO);
domain = mono_jit_init("hw.exe", "v2.0.50727");
printf("mono domain: %p\n", domain);
ma = mono_domain_assembly_open(domain, "hw.exe");
printf("mono assembly: %p\n", ma);
mi = mono_assembly_get_image(ma);
printf("mono image: %p\n", mi);
mc = mono_class_from_name(mi, "Test", "HelloWorld");
printf("mono class: %p\n", mc);
mmd = mono_method_desc_new("Test.HelloWorld:Foobar(int,string)", TRUE);
printf("mono desc method: %p\n", mmd);
mm = mono_method_desc_search_in_image(mmd, mi);
printf("mono method: %p\n", mm);
// add c functions for mono test code to invoke
mono_add_internal_call("Test.c_code::my_c_func", (void *) my_c_func);
mono_add_internal_call("Test.c_code::my_c_pass", (void *) my_c_pass);
mo = mono_runtime_invoke(mm, NULL, args, NULL);
printf("mono object: %p\n", mo);
if (NULL != corlib_data) free(corlib_data);
}
