static void
mono_set_port (void)
{
MonoObject *exc;
MonoMethod *method;
MonoClass *class;
MonoMethodDesc *desc;
MonoArray *v_args = NULL;
MonoAppDomain *domain_cls = mono_domain_get_appdomain (virtuoso_domain);
char *port;
port = virtuoso_odbc_port ();
class = mono_object_get_class ((MonoObject *) domain_cls);
desc = mono_method_desc_new ("System.AppDomain:SetData", 1);
method = mono_method_desc_search_in_class (desc, class);
v_args = MAKE_PARAM_ARRAY (virtuoso_domain, 2);
SET_STRING_ARG (virtuoso_domain, v_args, 0, "OpenLink.Virtuoso.InProcessPort");
SET_STRING_ARG (virtuoso_domain, v_args, 1, port);
mono_runtime_invoke_array (method, domain_cls, v_args, &exc);
}
static MonoObject *
mono_jit_exec_virt (MonoAssembly *assembly, char *mtd_name, MonoArray *v_args)
{
MonoImage *image = mono_assembly_get_image (assembly);
MonoMethod *method;
MonoClass *class;
MonoMethodDesc *desc;
MonoObject *exc = NULL, *ret;
class = mono_class_from_name (image, "", "VInvoke");
desc = mono_method_desc_new (mtd_name, 1);
method = mono_method_desc_search_in_image (desc, image);
mono_assembly_set_main (
mono_image_get_assembly (
mono_class_get_image (
mono_method_get_class (method))));
/*mono_start_method = mono_marshal_get_runtime_invoke (method);*/
ret = virt_mono_runtime_exec_main (method, v_args, &exc);
if (exc)
virt_mono_throw_unhandled_exception (exc);
return ret;
}
static int
get_spec (int *last)
{
int token = get_token ();
if (token == TOKEN_EXCLUDE){
token = get_spec (last);
if (token == TOKEN_EXCLUDE){
fprintf (stderr, "Expecting an expression");
return TOKEN_ERROR;
}
if (token == TOKEN_ERROR)
return token;
trace_spec.ops [(*last)-1].exclude = 1;
return TOKEN_SEPARATOR;
}
if (token == TOKEN_END || token == TOKEN_SEPARATOR || token == TOKEN_ERROR)
return token;
if (token == TOKEN_METHOD){
MonoMethodDesc *desc = mono_method_desc_new (value, TRUE);
if (desc == NULL){
fprintf (stderr, "Invalid method name: %s\n", value);
return TOKEN_ERROR;
}
trace_spec.ops [*last].op = MONO_TRACEOP_METHOD;
trace_spec.ops [*last].data = desc;
} else if (token == TOKEN_ALL)
trace_spec.ops [*last].op = MONO_TRACEOP_ALL;
else if (token == TOKEN_PROGRAM)
trace_spec.ops [*last].op = MONO_TRACEOP_PROGRAM;
else if (token == TOKEN_WRAPPER)
trace_spec.ops [*last].op = MONO_TRACEOP_WRAPPER;
else if (token == TOKEN_NAMESPACE){
trace_spec.ops [*last].op = MONO_TRACEOP_NAMESPACE;
trace_spec.ops [*last].data = g_strdup (value);
} else if (token == TOKEN_CLASS || token == TOKEN_EXCEPTION){
char *p = strrchr (value, '.');
if (p) {
*p++ = 0;
trace_spec.ops [*last].data = g_strdup (value);
trace_spec.ops [*last].data2 = g_strdup (p);
}
else {
trace_spec.ops [*last].data = g_strdup ("");
trace_spec.ops [*last].data2 = g_strdup (value);
}
trace_spec.ops [*last].op = token == TOKEN_CLASS ? MONO_TRACEOP_CLASS : MONO_TRACEOP_EXCEPTION;
} else if (token == TOKEN_STRING){
trace_spec.ops [*last].op = MONO_TRACEOP_ASSEMBLY;
trace_spec.ops [*last].data = g_strdup (value);
} else if (token == TOKEN_DISABLED) {
trace_spec.enabled = FALSE;
} else {
fprintf (stderr, "Syntax error in trace option specification\n");
return TOKEN_ERROR;
}
(*last)++;
return TOKEN_SEPARATOR;
}
GDMonoMethod *GDMonoClass::get_method_with_desc(const String &p_description, bool p_include_namespace) {
MonoMethodDesc *desc = mono_method_desc_new(p_description.utf8().get_data(), p_include_namespace);
MonoMethod *method = mono_method_desc_search_in_class(desc, mono_class);
mono_method_desc_free(desc);
ERR_FAIL_COND_V(mono_method_get_class(method) != mono_class, NULL);
return get_method(method);
}
MonoMethod *getMethodFromClass(MonoClass *cls, char *name) {
MonoMethodDesc *mdesc;
MonoMethod *method;
mdesc = mono_method_desc_new(name, 1);
method = mono_method_desc_search_in_class(mdesc, cls);
mono_method_desc_free(mdesc);
return method;
}
// Get string from a Mono exception
char* PyNet_ExceptionToString(MonoObject *e) {
MonoMethodDesc* mdesc = mono_method_desc_new(":ToString()", FALSE);
MonoMethod* mmethod = mono_method_desc_search_in_class(mdesc, mono_get_object_class());
mono_method_desc_free(mdesc);
mmethod = mono_object_get_virtual_method(e, mmethod);
MonoString* monoString = (MonoString*) mono_runtime_invoke(mmethod, e, NULL, NULL);
mono_runtime_invoke(mmethod, e, NULL, NULL);
return mono_string_to_utf8(monoString);
}
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;
}
CMMethodDescRef CMMethodDescCreate(CFAllocatorRef allocator, CFStringRef name, bool useNamespace) {
CMMethodDescRef methodDesc = NULL;
if (name) {
methodDesc = CFAllocatorAllocate(allocator, sizeof(__CMMethodDescType), 0);
if (methodDesc) {
methodDesc->allocator = allocator ? CFRetain(allocator) : NULL;
methodDesc->retainCount = 1;
methodDesc->useNamespace = useNamespace;
methodDesc->name = CFRetain(name);
IF_UTF8(allocator, name, utf8, {
if (NULL == (methodDesc->monoMethodDesc = mono_method_desc_new(utf8, useNamespace))) {
// TODO: error
}
});
}
}
void MonoAssembly::invoke(const String& functionName)
{
MonoMethodDesc* methodDesc = mono_method_desc_new(functionName.c_str(), false);
if(methodDesc != nullptr)
{
::MonoMethod* entry = mono_method_desc_search_in_image(methodDesc, mMonoImage);
if(entry != nullptr)
{
MonoObject* exception = nullptr;
mono_runtime_invoke(entry, nullptr, nullptr, &exception);
MonoUtil::throwIfException(exception);
}
}
}
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);
}
/**
* Returns the unmanaged thunk for the given @method_name method
* descriptor.
*/
void *sp_get_method_thunk(const char *method_name)
{
MonoMethodDesc *method_desc;
MonoMethod *method;
/* Create a MonoMethodDesc for the supplied method_name. */
method_desc = mono_method_desc_new(method_name, 1);
if (method_desc == NULL) {
printf("error: unable to create method desc\n");
_exit(0);
}
/* Try and find the method in the loaded assembly image. */
method = mono_method_desc_search_in_image(method_desc, m_image);
if (method == NULL) {
printf("error: unable to find method\n");
_exit(0);
}
/* Return the unmanaged thunk for the method. */
return mono_method_get_unmanaged_thunk(method);
}
void mono_cfg_dump_create_context (MonoCompile *cfg)
{
cfg->gdump_ctx = NULL;
if (!cfg_dump_method_inited) {
cfg_dump_method_name = g_getenv ("MONO_JIT_DUMP_METHOD");
cfg_dump_method_inited = TRUE;
}
if (!cfg_dump_method_name)
return;
const char *name = cfg_dump_method_name;
if ((strchr (name, '.') > name) || strchr (name, ':')) {
MonoMethodDesc *desc = mono_method_desc_new (name, TRUE);
gboolean failed = !mono_method_desc_full_match (desc, cfg->method);
mono_method_desc_free (desc);
if (failed)
return;
} else
if (strcmp (cfg->method->name, name) != 0)
return;
g_debug ("cfg_dump: create context for \"%s::%s\"", m_class_get_name (cfg->method->klass), cfg->method->name);
int fd = create_socket (DEFAULT_HOST, DEFAULT_PORT);
if (fd < 0) {
g_warning ("cfg_dump: couldn't create socket: %s::%d", DEFAULT_HOST, DEFAULT_PORT);
return;
}
MonoGraphDumper *ctx = (MonoGraphDumper *) mono_mempool_alloc0 (cfg->mempool, sizeof (MonoGraphDumper));
ctx->fd = fd;
ctx->constant_pool = g_hash_table_new ((GHashFunc) constant_pool_hash, constant_pool_equal);
ctx->insn2id = g_hash_table_new ((GHashFunc) instruction_hash, instruction_equal);
ctx->next_cp_id = 1;
ctx->next_insn_id = 0;
cfg->gdump_ctx = ctx;
}
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();
}
static void
load_roots (const char* filename)
{
FILE *file;
char buf [2048];
char *p, *s;
int line = 0;
MonoImage *image = NULL;
MonoClass *klass = NULL;
MonoClassField *field;
MonoMethodDesc *mdesc;
MonoMethod *method;
if (!(file = fopen (filename, "r")))
return;
while (fgets (buf, sizeof (buf), file)) {
/* FIXME:
* decide on the format to use to express types, fields, methods,
* maybe the same used on output from the tool, but with explicit
* names and signatures instead of token indexes
* add wildcard support
*/
++line;
s = buf;
while (*s && g_ascii_isspace (*s)) ++s;
switch (*s) {
case 0:
case '#':
continue; /* comment */
case '[':
p = strchr (s, ']');
if (!p)
g_error ("invalid assembly format at line %d\n", line);
*p = 0;
p = s + 1;
image = find_image (p);
if (!image)
g_error ("image not loaded: %s\n", p);
klass = NULL;
break;
case 'T':
if (s [1] != ':')
g_error ("invalid type format at line %d\n", line);
if (!image)
break;
klass = find_class (image, s + 2);
break;
case 'F':
if (s [1] != ':')
g_error ("invalid field format at line %d\n", line);
if (!image || !klass)
break;
p = s + 2;
if (*p == '*') {
handle_type (klass, TYPE_FIELDS);
break;
}
field = mono_class_get_field_from_name (klass, p);
if (!field)
g_warning ("no field '%s' at line %d\n", p, line);
else
add_field (field);
break;
case 'M':
if (s [1] != ':')
g_error ("invalid method format at line %d\n", line);
if (!image || !klass)
break;
p = s + 2;
if (*p == '*') {
handle_type (klass, TYPE_METHODS);
break;
}
mdesc = mono_method_desc_new (p, FALSE);
if (!mdesc) {
g_error ("invalid method desc at line %d\n", line);
}
method = mono_method_desc_search_in_class (mdesc, klass);
if (!method)
g_warning ("no method '%s' at line %d\n", p, line);
else
add_types_from_method (method);
mono_method_desc_free (mdesc);
break;
default:
g_error ("invalid format at line %d\n", line);
}
}
fclose (file);
}
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 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);
}