void main(int argc, char* argv[]) { mono_set_dirs("lib", ""); mono_config_parse(NULL); MonoDomain* domain = mono_jit_init("managed.exe"); if(!domain) { printf("Unable to initialize mono jit.\n"); return; } MonoAssembly* assembly = mono_domain_assembly_open(domain, "managed.exe"); if (!assembly) { printf("Unable to open assembly.\n"); return; } char* argvv[1] = { "managed" }; mono_jit_exec(domain, assembly, 1, argvv); mono_jit_cleanup(domain); return; }
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 ml_uninit() { g_return_if_fail(_runtime_active == TRUE); mono_jit_cleanup(ml_get_domain()); ml_set_domain(NULL); _runtime_active = FALSE; }
int app_mono_exec(struct sip_msg *msg, char *script, char *param) { int ret; char *argv[2]; int argc; argc = 1; argv[0] = script; if(param!=NULL) { argc++; argv[1] = param; } LM_DBG("executing Mono assembly: [[%s]]\n", argv[0]); _sr_M_env.msg = msg; mono_config_parse (NULL); /* * mono_jit_init() creates a domain: each assembly is * loaded and run in a MonoDomain. */ _sr_M_env.domain = mono_jit_init (argv[0]); /* * We add our special internal functions, so that C# code * can call us back. */ sr_mono_load_class_core(); sr_mono_load_class_pv(); sr_mono_load_class_hdr(); _sr_M_env.assembly = mono_domain_assembly_open(_sr_M_env.domain, argv[0]); if (_sr_M_env.assembly==NULL) { ret = -1; goto done; } /* * 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(_sr_M_env.domain, _sr_M_env.assembly, argc, argv); ret = mono_environment_exitcode_get(); LM_DBG("returned code from mono environment: %d\n", ret); done: mono_jit_cleanup(_sr_M_env.domain); memset(&_sr_M_env, 0, sizeof(sr_mono_env_t)); return (ret==0)?1:-1; }
// Shuts down PythonNet and cleans up Mono void PyNet_Finalize(PyNet_Args *pn_args) { MonoObject *exception = NULL; if (pn_args->shutdown) { mono_runtime_invoke(pn_args->shutdown, NULL, NULL, &exception); if (exception) { pn_args->error = PyNet_ExceptionToString(exception); } pn_args->shutdown = NULL; } if (pn_args->domain) { mono_jit_cleanup(pn_args->domain); pn_args->domain = NULL; } free(pn_args); }
int main (int argc, char *argv[]) { Global::Initialize(); std::cout << "Mono Native 1.0 Unit Tests" << std::endl; /* GlobalFixture globalfixture; globalfixture.Run(); List_1Fixture list_1Fixture; list_1Fixture.Run(); */ testing::InitGoogleTest(&argc, argv); int exitcode = RUN_ALL_TESTS(); mono_jit_cleanup(Global::GetDomain()); return exitcode; }
CScriptDomain::~CScriptDomain() { m_bDestroying = true; for each(auto assembly in m_assemblies) delete assembly; m_assemblies.clear(); if(m_bRootDomain) mono_jit_cleanup(m_pDomain); else { if(IsActive()) mono_domain_set(mono_get_root_domain(), false); mono_domain_finalize(m_pDomain, 2000); MonoObject *pException; try { mono_domain_try_unload(m_pDomain, &pException); } catch(char *ex) { MonoWarning("An exception was raised during ScriptDomain unload: %s", ex); } if(pException) { MonoWarning("An exception was raised during ScriptDomain unload:"); MonoMethod *pExceptionMethod = mono_method_desc_search_in_class(mono_method_desc_new("::ToString()", false),mono_get_exception_class()); MonoString *exceptionString = (MonoString *)mono_runtime_invoke(pExceptionMethod, pException, nullptr, nullptr); CryLogAlways(ToCryString((mono::string)exceptionString)); } } g_pScriptSystem->OnDomainReleased(this); }
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; }
static void processThroughMono(std::string& dll) { //Initialize mono runtime MonoDomain* domain = mono_jit_init (dll.c_str()); MonoAssembly *assembly; assembly = mono_domain_assembly_open (domain, dll.c_str()); assert(assembly); MonoImage *image = mono_assembly_get_image (assembly); assert(image); MonoMethodDesc* desc = mono_method_desc_new ("TestDLL.Program:process", true); assert(desc); MonoMethod* method = mono_method_desc_search_in_image (desc, image); assert(method); //Create our container Container* c = new Container(); //Cast to uint64 uint64_t ptr = reinterpret_cast<uint64_t>(c); //Fill it as an argument before the mono method invokation void* args[1]; args[0] = &ptr; //Invoke C# code mono_runtime_invoke (method, nullptr, args, nullptr); //Clean mono runtime mono_jit_cleanup (domain); //We did it! c->dump(); }
GDMono::~GDMono() { if (is_runtime_initialized()) { if (scripts_domain) { Error err = _unload_scripts_domain(); if (err != OK) { WARN_PRINT("Mono: Failed to unload scripts domain"); } } const uint32_t *k = NULL; while ((k = assemblies.next(k))) { HashMap<String, GDMonoAssembly *> &domain_assemblies = assemblies.get(*k); const String *kk = NULL; while ((kk = domain_assemblies.next(kk))) { memdelete(domain_assemblies.get(*kk)); } } assemblies.clear(); GDMonoUtils::clear_cache(); print_verbose("Mono: Runtime cleanup..."); mono_jit_cleanup(root_domain); runtime_initialized = false; } if (gdmono_log) memdelete(gdmono_log); singleton = NULL; }
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 ScriptProvider::Shutdown() { mono_jit_cleanup(ScriptDomain); }
__int32 WINAPI _CorExeMain(void) { int exit_code; int argc; char **argv; MonoDomain *domain=NULL; MonoImage *image; MonoImageOpenStatus status; MonoAssembly *assembly=NULL; WCHAR filename[MAX_PATH]; char *filenameA; ICLRRuntimeInfo *info; RuntimeHost *host; HRESULT hr; int i; get_utf8_args(&argc, &argv); GetModuleFileNameW(NULL, filename, MAX_PATH); TRACE("%s", debugstr_w(filename)); for (i=0; i<argc; i++) TRACE(" %s", debugstr_a(argv[i])); TRACE("\n"); filenameA = WtoA(filename); if (!filenameA) return -1; FixupVTable(GetModuleHandleW(NULL)); hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info); if (SUCCEEDED(hr)) { hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host); if (SUCCEEDED(hr)) hr = RuntimeHost_GetDefaultDomain(host, &domain); if (SUCCEEDED(hr)) { image = mono_image_open_from_module_handle(GetModuleHandleW(NULL), filenameA, 1, &status); if (image) assembly = mono_assembly_load_from(image, filenameA, &status); if (assembly) { mono_trace_set_assembly(assembly); exit_code = mono_jit_exec(domain, assembly, argc, argv); } else { ERR("couldn't load %s, status=%d\n", debugstr_w(filename), status); exit_code = -1; } RuntimeHost_DeleteDomain(host, domain); } else exit_code = -1; ICLRRuntimeInfo_Release(info); } else exit_code = -1; HeapFree(GetProcessHeap(), 0, argv); if (domain) { mono_thread_manage(); mono_jit_cleanup(domain); } return exit_code; }
//##################################################################### // Function ~Mono //##################################################################### MonoSystem::~MonoSystem() { reportPinnedObjects(); mDomain.fireProcessExit(); mono_jit_cleanup(mDomain.domain()); }
void SharpSource::SDK_OnUnload() { mono_jit_cleanup(domain); }