static HRESULT RuntimeHost_GetIUnknownForDomain(RuntimeHost *This, MonoDomain *domain, IUnknown **punk)
{
HRESULT hr;
void *args[1];
MonoAssembly *assembly;
MonoImage *image;
MonoClass *klass;
MonoMethod *method;
MonoObject *appdomain_object;
IUnknown *unk;
mono_thread_attach(domain);
assembly = mono_domain_assembly_open(domain, "mscorlib");
if (!assembly)
{
ERR("Cannot load mscorlib\n");
return E_FAIL;
}
image = mono_assembly_get_image(assembly);
if (!image)
{
ERR("Couldn't get assembly image\n");
return E_FAIL;
}
klass = mono_class_from_name(image, "System", "AppDomain");
if (!klass)
{
ERR("Couldn't get class from image\n");
return E_FAIL;
}
method = mono_class_get_method_from_name(klass, "get_CurrentDomain", 0);
if (!method)
{
ERR("Couldn't get method from class\n");
return E_FAIL;
}
args[0] = NULL;
appdomain_object = mono_runtime_invoke(method, NULL, args, NULL);
if (!appdomain_object)
{
ERR("Couldn't get result pointer\n");
return E_FAIL;
}
hr = RuntimeHost_GetIUnknownForObject(This, appdomain_object, &unk);
if (SUCCEEDED(hr))
{
hr = IUnknown_QueryInterface(unk, &IID__AppDomain, (void**)punk);
IUnknown_Release(unk);
}
return hr;
}
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 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;
}
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);
}
MaigreMonoBridge *
maigre_mono_bridge ()
{
static MaigreMonoBridge *bridge;
static gboolean load_attempted;
if (load_attempted) {
return bridge;
}
load_attempted = TRUE;
bridge = g_new0 (MaigreMonoBridge, 1);
bridge->domain = mono_domain_get ();
if (bridge->domain == NULL) {
mono_config_parse (NULL);
bridge->domain = mono_jit_init ("maigre-domain");
}
if ((bridge->assembly = mono_domain_assembly_open (
bridge->domain, ".run/engines/Maigre.dll")) == NULL ||
(bridge->image = mono_assembly_get_image (bridge->assembly)) == NULL) {
g_warning ("Could not load Maigre.dll assembly");
g_free (bridge);
bridge = NULL;
}
return bridge;
}
/* Get an IUnknown pointer for a Mono object.
*
* This is just a "light" wrapper around
* System.Runtime.InteropServices.Marshal:GetIUnknownForObject
*
* NOTE: The IUnknown* is created with a reference to the object.
* Until they have a reference, objects must be in the stack to prevent the
* garbage collector from freeing them.
*
* mono_thread_attach must have already been called for this thread. */
HRESULT RuntimeHost_GetIUnknownForObject(RuntimeHost *This, MonoObject *obj,
IUnknown **ppUnk)
{
MonoDomain *domain;
MonoAssembly *assembly;
MonoImage *image;
MonoClass *klass;
MonoMethod *method;
MonoObject *result;
void *args[2];
domain = mono_object_get_domain(obj);
assembly = mono_domain_assembly_open(domain, "mscorlib");
if (!assembly)
{
ERR("Cannot load mscorlib\n");
return E_FAIL;
}
image = mono_assembly_get_image(assembly);
if (!image)
{
ERR("Couldn't get assembly image\n");
return E_FAIL;
}
klass = mono_class_from_name(image, "System.Runtime.InteropServices", "Marshal");
if (!klass)
{
ERR("Couldn't get class from image\n");
return E_FAIL;
}
method = mono_class_get_method_from_name(klass, "GetIUnknownForObject", 1);
if (!method)
{
ERR("Couldn't get method from class\n");
return E_FAIL;
}
args[0] = obj;
args[1] = NULL;
result = mono_runtime_invoke(method, NULL, args, NULL);
if (!result)
{
ERR("Couldn't get result pointer\n");
return E_FAIL;
}
*ppUnk = *(IUnknown**)mono_object_unbox(result);
if (!*ppUnk)
{
ERR("GetIUnknownForObject returned 0\n");
return E_FAIL;
}
return S_OK;
}
int main()
{
#if LOADDYNAMIC
SetupMono();
#endif
#if WIN32
SetEnvironmentVariable(L"MONO_PATH",L"..\\..\\..\\builds\\monodistribution\\lib\\mono\\2.0");
#else
setenv("MONO_PATH","../../../builds/monodistribution/lib/mono/2.0",1);
#endif
MonoDomain* domain = mono_jit_init_version ("Unity Root Domain","v2.0.50727");
//create and set child domain
MonoDomain* child = mono_domain_create_appdomain("Unity Child Domain",NULL);
mono_domain_set(child,0);
//load assembly and call entrypoint
MonoAssembly* ass = mono_domain_assembly_open (mono_domain_get (),"lucas.exe");
MonoImage* img = mono_assembly_get_image(ass);
printf("image %p\n",img);
MonoMethodDesc* desc = mono_method_desc_new("Main2:Main",1);
MonoMethod* m = mono_method_desc_search_in_image(desc,img);
printf("method %p\n",m);
MonoObject* exc;
MonoObject* newinst = mono_object_new(mono_domain_get(),mono_method_get_class(m));
MonoObject* ret = mono_runtime_invoke(m,newinst,0,&exc);
printf ("Exception: %p\n",exc);
if (exc)
{
MonoException* exc2 = (MonoException*) exc;
printf ("exc msg:%s\n",mono_class_get_name(mono_object_get_class((MonoObject*)exc)));
}
printf ("ret: %p\n",ret);
Sleep(0);
//switch back to root domain
mono_domain_set(domain,0);
mono_domain_unload(child);
mono_runtime_set_shutting_down ();
mono_threads_set_shutting_down ();
mono_thread_pool_cleanup ();
mono_domain_finalize(mono_get_root_domain(),2000);
mono_runtime_cleanup(mono_get_root_domain());
printf("Unloading mono\n");
#if LOADDYNAMIC
CleanupMono();
#endif
while(1){} //sleep so stale monothreads have a chance to crash
return 0;
}
void RuntimeHost_ExitProcess(RuntimeHost *This, INT exitcode)
{
HRESULT hr;
void *args[2];
MonoDomain *domain;
MonoAssembly *assembly;
MonoImage *image;
MonoClass *klass;
MonoMethod *method;
hr = RuntimeHost_GetDefaultDomain(This, &domain);
if (FAILED(hr))
{
ERR("Cannot get domain, hr=%x\n", hr);
return;
}
mono_thread_attach(domain);
assembly = mono_domain_assembly_open(domain, "mscorlib");
if (!assembly)
{
ERR("Cannot load mscorlib\n");
return;
}
image = mono_assembly_get_image(assembly);
if (!image)
{
ERR("Couldn't get assembly image\n");
return;
}
klass = mono_class_from_name(image, "System", "Environment");
if (!klass)
{
ERR("Couldn't get class from image\n");
return;
}
method = mono_class_get_method_from_name(klass, "Exit", 1);
if (!method)
{
ERR("Couldn't get method from class\n");
return;
}
args[0] = &exitcode;
args[1] = NULL;
mono_runtime_invoke(method, NULL, args, NULL);
ERR("Process should have exited\n");
}
static void main_function (MonoDomain *domain, const char *file, int argc, char** argv)
{
MonoAssembly *assembly;
assembly = mono_domain_assembly_open (domain, file);
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, argv);
}
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;
}
IMonoAssembly *CScriptDomain::LoadAssembly(const char *file, bool shadowCopy, bool convertPdbToMdb)
{
const char *path;
if(shadowCopy)
path = GetTempPath().append(PathUtil::GetFile(file));
else
path = file;
for each(auto assembly in m_assemblies)
{
if(!strcmp(path, assembly->GetPath()))
return assembly;
}
if(shadowCopy)
CopyFile(file, path, false);
string sAssemblyPath(path);
#ifndef _RELEASE
if(g_pMonoCVars->mono_generateMdbIfPdbIsPresent != 0 && convertPdbToMdb && sAssemblyPath.find("pdb2mdb")==-1)
{
if (IMonoAssembly *pDebugDatabaseCreator = static_cast<CScriptSystem *>(GetMonoScriptSystem())->GetDebugDatabaseCreator())
{
if(IMonoClass *pDriverClass = pDebugDatabaseCreator->GetClass("Driver", ""))
{
if(IMonoMethod *pConvertMethod = pDriverClass->GetMethod("Convert", 1))
{
IMonoArray *pArgs = CreateMonoArray(1);
pArgs->Insert(path);
pConvertMethod->InvokeArray(nullptr, pArgs);
SAFE_RELEASE(pArgs);
}
}
}
}
#endif
if(MonoAssembly *pMonoAssembly = mono_domain_assembly_open(m_pDomain, path))
{
CScriptAssembly *pAssembly = new CScriptAssembly(this, mono_assembly_get_image(pMonoAssembly), path);
m_assemblies.push_back(pAssembly);
return pAssembly;
}
return nullptr;
}
static void main_thread_handler (gpointer user_data)
{
MainThreadArgs *main_args=(MainThreadArgs *)user_data;
MonoAssembly *assembly;
assembly = mono_domain_assembly_open (main_args->domain,
main_args->file);
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_interp_exec (main_args->domain, assembly, main_args->argc,
main_args->argv);
}
int main(int argc, char* argv[])
{
MonoDomain *domain;
MonoAssembly *assembly;
const char *file;
int retval;
if (argc < 2)
{
fprintf(stderr, "Please provide name of mono 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);
// Create mono AppDomain
domain = mono_jit_init(file);
// Open entry assembly in new AppDomain
assembly = mono_domain_assembly_open(domain, file);
if (assembly != NULL)
{
// mono_jit_exec runs the Main() method in the assembly
mono_jit_exec(domain, assembly, argc - 1, argv + 1);
// Get exit code from entry assembly
retval = mono_environment_exitcode_get();
}
else
{
fprintf(stderr, "Failed to load mono assembly: %s\n", file);
retval = 2;
}
// This clean up call tends to crash - since we are exiting anyway, we skip it...
//mono_jit_cleanup(domain);
return retval;
}
void mono_convert_symbols(const char * path) {
std::string converter_path_string = PathUtil::GetLibDirectory()
.append("mono/4.5/pdb2mdb.exe");
char *converter_path = new char[converter_path_string.size() + 1];
converter_path[converter_path_string.size()] = 0;
memcpy(converter_path, converter_path_string.c_str(),
converter_path_string.size());
MonoAssembly *converter_assembly = mono_domain_assembly_open(
mono_domain_get(), converter_path);
assert(converter_assembly);
char * argv[2];
argv[0] = (char *)converter_path;
argv[1] = (char *)path;
mono_jit_exec(mono_domain_get(), converter_assembly, 2, argv);
}
bool SharpSource::SDK_OnLoad(char *error, size_t maxlength, bool late)
{
domain = mono_jit_init(library);
assembly = mono_domain_assembly_open(domain, library);
char cwd[1024];
if (!assembly) {
strcpy(error, "Can't find the .NET assembly file in the sharpmod directory");
return false;
}
MonoImage *image = mono_assembly_get_image(assembly);
if (!image) {
strcpy(error, "Can't load the assembly image");
return false;
}
MonoClass *metamod_class = mono_class_from_name(image, "AlliedMods", "Core");
if (!metamod_class) {
strcpy(error, "Can't find the class SharpSource::MainClass in the provided assembly");
return false;
}
MonoMethod *init = mono_class_get_method_from_name(metamod_class, "Init", 5);
if (!init) {
strcpy(error, "Can't find the method Init in MainClass");
return false;
}
void *args[5];
args[0] = &smutils;
args[1] = &sharesys;
args[2] = &myself;
args[3] = &playerhelpers;
args[4] = &timersys;
mono_runtime_invoke(init, NULL, args, NULL);
return true;
}
IMonoAssembly *CScriptDomain::LoadAssembly(const char *file, bool shadowCopy, bool convertPdbToMdb)
{
const char *path;
if(shadowCopy)
path = GetTempPath().append(PathUtil::GetFile(file));
else
path = file;
for each(auto assembly in m_assemblies)
{
if(!strcmp(path, assembly->GetPath()))
return assembly;
}
if(shadowCopy)
CopyFile(file, path, false);
string sAssemblyPath(path);
#ifndef _RELEASE
if(convertPdbToMdb && sAssemblyPath.find("pdb2mdb")==-1)
{
if(IMonoAssembly *pDebugDatabaseCreator = g_pScriptSystem->GetDebugDatabaseCreator())
{
if(IMonoClass *pDriverClass = pDebugDatabaseCreator->GetClass("Driver", ""))
{
IMonoArray *pArgs = CreateMonoArray(1);
pArgs->Insert(path);
pDriverClass->InvokeArray(NULL, "Convert", pArgs);
SAFE_RELEASE(pArgs);
}
}
}
#endif
MonoAssembly *pMonoAssembly = mono_domain_assembly_open(m_pDomain, path);
CRY_ASSERT(pMonoAssembly);
CScriptAssembly *pAssembly = new CScriptAssembly(this, mono_assembly_get_image(pMonoAssembly), path);
m_assemblies.push_back(pAssembly);
return pAssembly;
}
/**
* 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;
}
void ScriptProvider::Initialize()
{
const char* szScriptAssembly = "TalonScript.dll";
ScriptDomain = mono_jit_init(szScriptAssembly);
ScriptAssembly = mono_domain_assembly_open(ScriptDomain, szScriptAssembly);
ScriptAssemblyImage = mono_assembly_get_image(ScriptAssembly);
Module.SetDomain(ScriptDomain);
Module.SetImage(ScriptAssemblyImage);
printf("Mapping Scripted Types:\n");
std::vector<ScriptType*>::iterator itCurrent = s_registeredTypes->begin();
std::vector<ScriptType*>::iterator itEnd = s_registeredTypes->end();
while (itCurrent != itEnd)
{
ScriptType* pType = *itCurrent;
printf("\t%s\n", pType->GetName());
pType->MapType();
itCurrent++;
}
}
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();
}
int mono_sr_init_load(void)
{
sr_mono_load_t *mi;
if(_sr_mono_load_list == NULL) {
LM_DBG("no assembly to load\n");
return 0;
}
mono_config_parse (NULL);
mi = _sr_mono_load_list;
if(mi && mi->domain != NULL)
{
LM_ERR("worker mono environment already initialized\n");
return 0;
}
while(mi!=NULL)
{
mi->domain = mono_jit_init (mi->script);
if (mi->domain==NULL) {
LM_ERR("failed to init domain for: %s\n", mi->script);
return -1;
}
sr_mono_load_class_core();
sr_mono_load_class_pv();
sr_mono_load_class_hdr();
mi->assembly = mono_domain_assembly_open(mi->domain, mi->script);
if (mi->assembly==NULL) {
LM_ERR("failed to open assembly: %s\n", mi->script);
return -1;
}
mi = mi->next;
/* only one (first) assembly for now */
break;
}
return 0;
}
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 main_thread_handler (gpointer user_data) {
PyNet_Args *pn_args=(PyNet_Args *)user_data;
MonoMethod *init;
MonoImage *pr_image;
MonoClass *pythonengine;
MonoObject *exception = NULL;
MonoObject *init_result;
#ifndef _WIN32
// Get the filename of the python shared object and set
// LD_LIBRARY_PATH so Mono can find it.
Dl_info dlinfo = {0};
if (0 != dladdr(&Py_Initialize, &dlinfo)) {
char* fname = alloca(strlen(dlinfo.dli_fname) + 1);
strcpy(fname, dlinfo.dli_fname);
char* py_libdir = dirname(fname);
char* ld_library_path = getenv("LD_LIBRARY_PATH");
if (NULL == ld_library_path) {
setenv("LD_LIBRARY_PATH", py_libdir, 1);
} else {
char* new_ld_library_path = alloca(strlen(py_libdir)
+ strlen(ld_library_path)
+ 2);
strcpy(new_ld_library_path, py_libdir);
strcat(new_ld_library_path, ":");
strcat(new_ld_library_path, ld_library_path);
setenv("LD_LIBRARY_PATH", py_libdir, 1);
}
}
//get python path system variable
PyObject* syspath = PySys_GetObject("path");
char* runtime_full_path = (char*) malloc(1024);
const char* slash = "/";
int found = 0;
int ii = 0;
for (ii = 0; ii < PyList_Size(syspath); ++ii) {
#if PY_MAJOR_VERSION > 2
Py_ssize_t wlen;
wchar_t *wstr = PyUnicode_AsWideCharString(PyList_GetItem(syspath, ii), &wlen);
char* pydir = (char*)malloc(wlen + 1);
size_t mblen = wcstombs(pydir, wstr, wlen + 1);
if (mblen > wlen)
pydir[wlen] = '\0';
PyMem_Free(wstr);
#else
const char* pydir = PyString_AsString(PyList_GetItem(syspath, ii));
#endif
char* curdir = (char*) malloc(1024);
strncpy(curdir, strlen(pydir) > 0 ? pydir : ".", 1024);
strncat(curdir, slash, 1024);
#if PY_MAJOR_VERSION > 2
free(pydir);
#endif
//look in this directory for the pn_args->pr_file
DIR* dirp = opendir(curdir);
if (dirp != NULL) {
struct dirent *dp;
while ((dp = readdir(dirp)) != NULL) {
if (strcmp(dp->d_name, pn_args->pr_file) == 0) {
strcpy(runtime_full_path, curdir);
strcat(runtime_full_path, pn_args->pr_file);
found = 1;
break;
}
}
closedir(dirp);
}
free(curdir);
if (found) {
pn_args->pr_file = runtime_full_path;
break;
}
}
if (!found) {
fprintf(stderr, "Could not find assembly %s. \n", pn_args->pr_file);
return;
}
#endif
pn_args->pr_assm = mono_domain_assembly_open(pn_args->domain, pn_args->pr_file);
if (!pn_args->pr_assm) {
pn_args->error = "Unable to load assembly";
return;
}
#ifndef _WIN32
free(runtime_full_path);
#endif
pr_image = mono_assembly_get_image(pn_args->pr_assm);
if (!pr_image) {
pn_args->error = "Unable to get image";
return;
}
pythonengine = mono_class_from_name(pr_image, "Python.Runtime", "PythonEngine");
if (!pythonengine) {
pn_args->error = "Unable to load class PythonEngine from Python.Runtime";
return;
}
init = getMethodFromClass(pythonengine, pn_args->init_name);
if (!init) {
pn_args->error = "Unable to fetch Init method from PythonEngine";
return;
}
pn_args->shutdown = getMethodFromClass(pythonengine, pn_args->shutdown_name);
if (!pn_args->shutdown) {
pn_args->error = "Unable to fetch shutdown method from PythonEngine";
return;
}
init_result = mono_runtime_invoke(init, NULL, NULL, &exception);
if (exception) {
pn_args->error = PyNet_ExceptionToString(exception);
return;
}
#if PY_MAJOR_VERSION >= 3
if (NULL != init_result)
pn_args->module = *(PyObject**)mono_object_unbox(init_result);
#endif
}
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);
}
static MonoObject *
call_mono (caddr_t file_name, caddr_t mtd_name, MonoArray *v_args, MonoDomain *domain)
{
MonoAssembly *assembly = mono_domain_assembly_open (domain, file_name);
return mono_jit_exec_virt (assembly, mtd_name, v_args);
}
HRESULT create_monodata(REFIID riid, LPVOID *ppObj )
{
static const WCHAR wszAssembly[] = {'A','s','s','e','m','b','l','y',0};
static const WCHAR wszCodebase[] = {'C','o','d','e','B','a','s','e',0};
static const WCHAR wszClass[] = {'C','l','a','s','s',0};
static const WCHAR wszFileSlash[] = {'f','i','l','e',':','/','/','/',0};
static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
static const WCHAR wszInprocServer32[] = {'\\','I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
static const WCHAR wszDLL[] = {'.','d','l','l',0};
WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) + ARRAYSIZE(wszInprocServer32) - 1];
MonoDomain *domain;
MonoAssembly *assembly;
ICLRRuntimeInfo *info = NULL;
RuntimeHost *host;
HRESULT hr;
HKEY key, subkey;
LONG res;
int offset = 0;
DWORD numKeys, keyLength;
WCHAR codebase[MAX_PATH + 8];
WCHAR classname[350], subkeyName[256];
WCHAR filename[MAX_PATH];
DWORD dwBufLen = 350;
lstrcpyW(path, wszCLSIDSlash);
StringFromGUID2(riid, path + lstrlenW(wszCLSIDSlash), CHARS_IN_GUID);
lstrcatW(path, wszInprocServer32);
TRACE("Registry key: %s\n", debugstr_w(path));
res = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &key);
if (res == ERROR_FILE_NOT_FOUND)
return CLASS_E_CLASSNOTAVAILABLE;
res = RegGetValueW( key, NULL, wszClass, RRF_RT_REG_SZ, NULL, classname, &dwBufLen);
if(res != ERROR_SUCCESS)
{
WARN("Class value cannot be found.\n");
hr = CLASS_E_CLASSNOTAVAILABLE;
goto cleanup;
}
TRACE("classname (%s)\n", debugstr_w(classname));
dwBufLen = MAX_PATH + 8;
res = RegGetValueW( key, NULL, wszCodebase, RRF_RT_REG_SZ, NULL, codebase, &dwBufLen);
if(res == ERROR_SUCCESS)
{
/* Strip file:/// */
if(strncmpW(codebase, wszFileSlash, strlenW(wszFileSlash)) == 0)
offset = strlenW(wszFileSlash);
strcpyW(filename, codebase + offset);
}
else
{
WCHAR assemblyname[MAX_PATH + 8];
hr = CLASS_E_CLASSNOTAVAILABLE;
WARN("CodeBase value cannot be found, trying Assembly.\n");
/* get the last subkey of InprocServer32 */
res = RegQueryInfoKeyW(key, 0, 0, 0, &numKeys, 0, 0, 0, 0, 0, 0, 0);
if (res != ERROR_SUCCESS || numKeys == 0)
goto cleanup;
numKeys--;
keyLength = sizeof(subkeyName) / sizeof(WCHAR);
res = RegEnumKeyExW(key, numKeys, subkeyName, &keyLength, 0, 0, 0, 0);
if (res != ERROR_SUCCESS)
goto cleanup;
res = RegOpenKeyExW(key, subkeyName, 0, KEY_READ, &subkey);
if (res != ERROR_SUCCESS)
goto cleanup;
dwBufLen = MAX_PATH + 8;
res = RegGetValueW(subkey, NULL, wszAssembly, RRF_RT_REG_SZ, NULL, assemblyname, &dwBufLen);
RegCloseKey(subkey);
if (res != ERROR_SUCCESS)
goto cleanup;
hr = get_file_from_strongname(assemblyname, filename, MAX_PATH);
if (!SUCCEEDED(hr))
{
/*
* The registry doesn't have a CodeBase entry and it's not in the GAC.
*
* Use the Assembly Key to retrieve the filename.
* Assembly : REG_SZ : AssemblyName, Version=X.X.X.X, Culture=neutral, PublicKeyToken=null
*/
WCHAR *ns;
WARN("Attempt to load from the application directory.\n");
GetModuleFileNameW(NULL, filename, MAX_PATH);
ns = strrchrW(filename, '\\');
*(ns+1) = '\0';
ns = strchrW(assemblyname, ',');
*(ns) = '\0';
strcatW(filename, assemblyname);
*(ns) = '.';
strcatW(filename, wszDLL);
}
}
TRACE("filename (%s)\n", debugstr_w(filename));
*ppObj = 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))
{
MonoImage *image;
MonoClass *klass;
MonoObject *result;
IUnknown *unk = NULL;
char *filenameA, *ns;
char *classA;
hr = CLASS_E_CLASSNOTAVAILABLE;
mono_thread_attach(domain);
filenameA = WtoA(filename);
assembly = mono_domain_assembly_open(domain, filenameA);
HeapFree(GetProcessHeap(), 0, filenameA);
if (!assembly)
{
ERR("Cannot open assembly %s\n", filenameA);
goto cleanup;
}
image = mono_assembly_get_image(assembly);
if (!image)
{
ERR("Couldn't get assembly image\n");
goto cleanup;
}
classA = WtoA(classname);
ns = strrchr(classA, '.');
*ns = '\0';
klass = mono_class_from_name(image, classA, ns+1);
HeapFree(GetProcessHeap(), 0, classA);
if (!klass)
{
ERR("Couldn't get class from image\n");
goto cleanup;
}
/*
* Use the default constructor for the .NET class.
*/
result = mono_object_new(domain, klass);
mono_runtime_object_init(result);
hr = RuntimeHost_GetIUnknownForObject(host, result, &unk);
if (SUCCEEDED(hr))
{
hr = IUnknown_QueryInterface(unk, &IID_IUnknown, ppObj);
IUnknown_Release(unk);
}
else
hr = CLASS_E_CLASSNOTAVAILABLE;
}
else
hr = CLASS_E_CLASSNOTAVAILABLE;
}
else
hr = CLASS_E_CLASSNOTAVAILABLE;
cleanup:
if(info)
ICLRRuntimeInfo_Release(info);
RegCloseKey(key);
return hr;
}
break;
}
}
LeaveCriticalSection(&This->lock);
}
static BOOL RuntimeHost_GetMethod(MonoDomain *domain, const char *assemblyname,
const char *namespace, const char *typename, const char *methodname, int arg_count,
MonoMethod **method)
{
MonoAssembly *assembly;
MonoImage *image;
MonoClass *klass;
assembly = mono_domain_assembly_open(domain, assemblyname);
if (!assembly)
{
ERR("Cannot load assembly %s\n", assemblyname);
return FALSE;
}
image = mono_assembly_get_image(assembly);
if (!image)
{
ERR("Couldn't get assembly image for %s\n", assemblyname);
return FALSE;
}
klass = mono_class_from_name(image, namespace, typename);
if (!klass)
int main(int argc, char** argv)
{
std::string app_base;
std::string assembly_path;
// REVIEW: Not reliable (figure out how to do this in a portable way)
if(argc > 0)
{
assembly_path = argv[0];
app_base = assembly_path.substr(0, assembly_path.length() - 3);
assembly_path = app_base + s_managed_assembly_name;
}
MonoDomain* domain = mono_jit_init ("klr");
if(domain == NULL)
{
printf("Failed to create mono runtime\n");
return -1;
}
MonoAssembly* assembly = mono_domain_assembly_open(domain, assembly_path.c_str());
if(assembly == NULL)
{
printf("Unable to locate klr.mono.managed.dll\n");
return -1;
}
MonoImage* image = mono_assembly_get_image(assembly);
if(image == NULL)
{
printf("Unable to get mono image for klr.mono.managed.dll\n");
return -1;
}
MonoClass* klass = mono_class_from_name(image, "", "EntryPoint");
if(image == NULL)
{
printf("Unable to get class for EntryPoint\n");
return -1;
}
MonoMethod* method = mono_class_get_method_from_name(klass, "Main", 2);
if(method == NULL)
{
printf("Unable to find Main method\n");
return -1;
}
MonoObject* exception;
void* args[2];
args[0] = &argc;
args[1] = argv;
mono_runtime_invoke(method, NULL, args, &exception);
if(exception != NULL)
{
mono_print_unhandled_exception(exception);
return -1;
}
return 0;
}
void main_thread_handler (gpointer user_data) {
PyNet_Args *pn_args=(PyNet_Args *)user_data;
MonoMethod *init;
MonoImage *pr_image;
MonoClass *pythonengine;
MonoObject *exception = NULL;
#ifndef _WIN32
//get python path system variable
PyObject* syspath = PySys_GetObject("path");
char* runtime_full_path = (char*) malloc(1024);
const char* slash = "/";
int found = 0;
int ii = 0;
for (ii = 0; ii < PyList_Size(syspath); ++ii) {
const char* pydir = PyString_AsString(PyList_GetItem(syspath, ii));
char* curdir = (char*) malloc(1024);
strncpy(curdir, strlen(pydir) > 0 ? pydir : ".", 1024);
strncat(curdir, slash, 1024);
//look in this directory for the pn_args->pr_file
DIR* dirp = opendir(curdir);
if (dirp != NULL) {
struct dirent *dp;
while ((dp = readdir(dirp)) != NULL) {
if (strcmp(dp->d_name, pn_args->pr_file) == 0) {
strcpy(runtime_full_path, curdir);
strcat(runtime_full_path, pn_args->pr_file);
found = 1;
break;
}
}
closedir(dirp);
}
free(curdir);
if (found) {
pn_args->pr_file = runtime_full_path;
break;
}
}
if (!found) {
fprintf(stderr, "Could not find assembly %s. \n", pn_args->pr_file);
return;
}
#endif
pn_args->pr_assm = mono_domain_assembly_open(pn_args->domain, pn_args->pr_file);
if (!pn_args->pr_assm) {
pn_args->error = "Unable to load assembly";
return;
}
#ifndef _WIN32
free(runtime_full_path);
#endif
pr_image = mono_assembly_get_image(pn_args->pr_assm);
if (!pr_image) {
pn_args->error = "Unable to get image";
return;
}
pythonengine = mono_class_from_name(pr_image, "Python.Runtime", "PythonEngine");
if (!pythonengine) {
pn_args->error = "Unable to load class PythonEngine from Python.Runtime";
return;
}
init = getMethodFromClass(pythonengine, pn_args->init_name);
if (!init) {
pn_args->error = "Unable to fetch Init method from PythonEngine";
return;
}
pn_args->shutdown = getMethodFromClass(pythonengine, pn_args->shutdown_name);
if (!pn_args->shutdown) {
pn_args->error = "Unable to fetch shutdown method from PythonEngine";
return;
}
mono_runtime_invoke(init, NULL, NULL, &exception);
if (exception) {
pn_args->error = PyNet_ExceptionToString(exception);
return;
}
}
static HRESULT WINAPI CLRRuntimeHost_ExecuteInDefaultAppDomain(ICLRRuntimeHost* iface,
LPCWSTR pwzAssemblyPath, LPCWSTR pwzTypeName, LPCWSTR pwzMethodName,
LPCWSTR pwzArgument, DWORD *pReturnValue)
{
RuntimeHost *This = impl_from_ICLRRuntimeHost( iface );
HRESULT hr;
MonoDomain *domain;
MonoAssembly *assembly;
MonoImage *image;
MonoClass *klass;
MonoMethod *method;
MonoObject *result;
MonoString *str;
void *args[2];
char *filenameA = NULL, *classA = NULL, *methodA = NULL;
char *argsA = NULL, *ns;
TRACE("(%p,%s,%s,%s,%s)\n", iface, debugstr_w(pwzAssemblyPath),
debugstr_w(pwzTypeName), debugstr_w(pwzMethodName), debugstr_w(pwzArgument));
hr = RuntimeHost_GetDefaultDomain(This, &domain);
if(hr != S_OK)
{
ERR("Couldn't get Default Domain\n");
return hr;
}
hr = E_FAIL;
mono_thread_attach(domain);
filenameA = WtoA(pwzAssemblyPath);
assembly = mono_domain_assembly_open(domain, filenameA);
if (!assembly)
{
ERR("Cannot open assembly %s\n", filenameA);
goto cleanup;
}
image = mono_assembly_get_image(assembly);
if (!image)
{
ERR("Couldn't get assembly image\n");
goto cleanup;
}
classA = WtoA(pwzTypeName);
ns = strrchr(classA, '.');
*ns = '\0';
klass = mono_class_from_name(image, classA, ns+1);
if (!klass)
{
ERR("Couldn't get class from image\n");
goto cleanup;
}
methodA = WtoA(pwzMethodName);
method = mono_class_get_method_from_name(klass, methodA, 1);
if (!method)
{
ERR("Couldn't get method from class\n");
goto cleanup;
}
/* The .NET function we are calling has the following declaration
* public static int functionName(String param)
*/
argsA = WtoA(pwzArgument);
str = mono_string_new(domain, argsA);
args[0] = str;
args[1] = NULL;
result = mono_runtime_invoke(method, NULL, args, NULL);
if (!result)
ERR("Couldn't get result pointer\n");
else
{
*pReturnValue = *(DWORD*)mono_object_unbox(result);
hr = S_OK;
}
cleanup:
HeapFree(GetProcessHeap(), 0, filenameA);
HeapFree(GetProcessHeap(), 0, classA);
HeapFree(GetProcessHeap(), 0, argsA);
HeapFree(GetProcessHeap(), 0, methodA);
return hr;
}
