static void OutputExceptionDetails(MonoObject* exc)
{
MonoClass* eclass = mono_object_get_class(exc);
if (eclass)
{
MonoObject* toStringExc = nullptr;
MonoString* msg = mono_object_to_string(exc, &toStringExc);
MonoProperty* prop = mono_class_get_property_from_name(eclass, "StackTrace");
MonoMethod* getter = mono_property_get_get_method(prop);
MonoString* msg2 = (MonoString*)mono_runtime_invoke(getter, exc, NULL, NULL);
if (toStringExc)
{
MonoProperty* prop = mono_class_get_property_from_name(eclass, "Message");
MonoMethod* getter = mono_property_get_get_method(prop);
msg = (MonoString*)mono_runtime_invoke(getter, exc, NULL, NULL);
}
GlobalError("Unhandled exception in Mono script environment: %s %s", mono_string_to_utf8(msg), mono_string_to_utf8(msg2));
}
}
// 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);
}
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;
}
void invoke_protected_memory_method (MonoArray *data, MonoObject *scope, gboolean encrypt)
{
MonoClass *klass;
MonoMethod *method;
void *params [2];
MONO_ARCH_SAVE_REGS;
if (system_security_assembly == NULL) {
system_security_assembly = mono_image_loaded ("System.Security");
if (!system_security_assembly) {
MonoAssembly *sa = mono_assembly_open ("System.Security.dll", NULL);
if (!sa)
g_assert_not_reached ();
system_security_assembly = mono_assembly_get_image (sa);
}
}
klass = mono_class_from_name (system_security_assembly,
"System.Security.Cryptography", "ProtectedMemory");
method = mono_class_get_method_from_name (klass, encrypt ? "Protect" : "Unprotect", 2);
params [0] = data;
params [1] = scope; /* MemoryProtectionScope.SameProcess */
mono_runtime_invoke (method, NULL, params, NULL);
}
/*
* Ensure that the restrictions for partially trusted code are satisfied.
*
* @domain The current application domain
* @assembly The assembly to query
* return value: TRUE if the assembly is runnning at FullTrust, FALSE otherwise.
*/
static gboolean
mono_declsec_is_assembly_fulltrust (MonoDomain *domain, MonoAssembly *assembly)
{
if (!MONO_SECMAN_FLAG_INIT (assembly->fulltrust)) {
MonoReflectionAssembly *refass = (MonoReflectionAssembly*) mono_assembly_get_object (domain, assembly);
MonoSecurityManager *secman = mono_security_manager_get_methods ();
if (secman && refass) {
MonoObject *res;
gpointer args [1];
args [0] = refass;
res = mono_runtime_invoke (secman->linkdemandfulltrust, NULL, args, NULL);
if (*(MonoBoolean *) mono_object_unbox(res)) {
/* keep this value cached as it will be used very often */
MONO_SECMAN_FLAG_SET_VALUE (assembly->fulltrust, TRUE);
return TRUE;
}
}
MONO_SECMAN_FLAG_SET_VALUE (assembly->fulltrust, FALSE);
return FALSE;
}
return MONO_SECMAN_FLAG_GET_VALUE (assembly->fulltrust);
}
JNIEXPORT void JNICALL Java_com_koushikdutta_monojavabridge_MonoBridge_loadAssembly
(JNIEnv *env, jclass clazz, jstring assembly)
{
void *args[1];
args[0] = &assembly;
mono_runtime_invoke(g_LoadAssembly, NULL, args, NULL);
}
/**
* mono_get_exception_type_initialization:
* @type_name: the name of the type that failed to initialize.
* @inner: the inner exception.
*
* Returns: a new instance of the System.TypeInitializationException
*/
MonoException *
mono_get_exception_type_initialization (const gchar *type_name, MonoException *inner)
{
MonoClass *klass;
gpointer args [2];
MonoObject *exc;
MonoMethod *method;
gpointer iter;
klass = mono_class_from_name (mono_get_corlib (), "System", "TypeInitializationException");
g_assert (klass);
mono_class_init (klass);
/* TypeInitializationException only has 1 ctor with 2 args */
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
if (!strcmp (".ctor", mono_method_get_name (method)) && mono_method_signature (method)->param_count == 2)
break;
method = NULL;
}
g_assert (method);
args [0] = mono_string_new (mono_domain_get (), type_name);
args [1] = inner;
exc = mono_object_new (mono_domain_get (), klass);
mono_runtime_invoke (method, exc, args, NULL);
return (MonoException *) exc;
}
result_t MonoCreateObjectInstance(const guid_t& guid, const guid_t& iid, void** objectRef)
{
MonoEnsureThreadAttached();
MonoObject* exc = nullptr;
guid_t lguid = guid;
guid_t liid = iid;
void* args[2];
args[0] = &lguid;
args[1] = &liid;
auto retval = mono_runtime_invoke(g_createObjectMethod, nullptr, args, &exc);
if (exc)
{
return FX_E_NOINTERFACE;
}
*objectRef = *(void**)(mono_object_unbox(retval));
if (!*objectRef)
{
return FX_E_NOINTERFACE;
}
return FX_S_OK;
}
/* 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;
}
MonoObject* MonoMethod::invoke(MonoObject* instance, void** params)
{
MonoObject* exception = nullptr;
MonoObject* retVal = mono_runtime_invoke(mMethod, instance, params, &exception);
MonoUtil::throwIfException(exception);
return retVal;
}
/* Returns the exception thrown when invoking, if any */
static MonoObject *
mono_async_invoke (ThreadPool *tp, MonoAsyncResult *ares)
{
ASyncCall *ac = (ASyncCall *)ares->object_data;
MonoObject *res, *exc = NULL;
MonoArray *out_args = NULL;
HANDLE wait_event = NULL;
if (ares->execution_context) {
/* use captured ExecutionContext (if available) */
MONO_OBJECT_SETREF (ares, original_context, mono_thread_get_execution_context ());
mono_thread_set_execution_context (ares->execution_context);
} else {
ares->original_context = NULL;
}
if (ac == NULL) {
/* Fast path from ThreadPool.*QueueUserWorkItem */
void *pa = ares->async_state;
mono_runtime_delegate_invoke (ares->async_delegate, &pa, &exc);
} else {
MonoObject *cb_exc = NULL;
ac->msg->exc = NULL;
res = mono_message_invoke (ares->async_delegate, ac->msg, &exc, &out_args);
MONO_OBJECT_SETREF (ac, res, res);
MONO_OBJECT_SETREF (ac, msg->exc, exc);
MONO_OBJECT_SETREF (ac, out_args, out_args);
mono_monitor_enter ((MonoObject *) ares);
ares->completed = 1;
if (ares->handle != NULL)
wait_event = mono_wait_handle_get_handle ((MonoWaitHandle *) ares->handle);
mono_monitor_exit ((MonoObject *) ares);
/* notify listeners */
if (wait_event != NULL)
SetEvent (wait_event);
/* call async callback if cb_method != null*/
if (ac != NULL && ac->cb_method) {
void *pa = &ares;
cb_exc = NULL;
mono_runtime_invoke (ac->cb_method, ac->cb_target, pa, &cb_exc);
MONO_OBJECT_SETREF (ac->msg, exc, cb_exc);
exc = cb_exc;
} else {
exc = NULL;
}
}
/* restore original thread execution context if flow isn't suppressed, i.e. non null */
if (ares->original_context) {
mono_thread_set_execution_context (ares->original_context);
ares->original_context = NULL;
}
return exc;
}
JNIEXPORT void JNICALL Java_com_koushikdutta_monojavabridge_MonoBridge_link
(JNIEnv *env, jclass clazz, jclass cls, jstring methodName, jstring methodSignature, jstring methodParameters)
{
void *args[4];
args[0] = &cls;
args[1] = &methodName;
args[2] = &methodSignature;
args[3] = &methodParameters;
mono_runtime_invoke(g_Link, NULL, args, NULL);
}
void DOMBase::SetNextWrapper(MonoObject* next)
{
if (_setNextWrapperMethod == NULL)
FindSetNextWrapper();
void *args[2];
args[0] = GetJSWrapper();
args[1] = next;
mono_runtime_invoke(_setNextWrapperMethod, NULL, args, NULL);
}
void DOMBase::SetPrevWrapper(MonoObject* prev)
{
if (_setPrevWrapperMethod == NULL)
FindSetPrevWrapper();
void *args[2];
args[0] = GetJSWrapper();
args[1] = prev;
mono_runtime_invoke(_setPrevWrapperMethod, NULL, args, NULL);
}
MonoObject* MonoMethod::invokeVirtual(MonoObject* instance, void** params)
{
::MonoMethod* virtualMethod = mono_object_get_virtual_method(instance, mMethod);
MonoObject* exception = nullptr;
MonoObject* retVal = mono_runtime_invoke(virtualMethod, instance, params, &exception);
MonoUtil::throwIfException(exception);
return retVal;
}
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 JniManager::toProcessRequest(jobject obj, MonoObject* processRequest)
{
JNIEnv* env = getEnv();
MonoDomain* monoDomain = getMonoDomain();
string c_assemblyName = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getAssemblyName, "()Ljava/lang/String;"));
string c_assemblyPath = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getAssemblyPath, "()Ljava/lang/String;"));
string c_methodName = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getMethodName, "()Ljava/lang/String;"));
MonoString* assemblyName = mono_string_new(monoDomain, c_assemblyName.c_str());
MonoString* assemblyPath = mono_string_new(monoDomain, c_assemblyPath.c_str());
MonoString* methodName = mono_string_new(monoDomain, c_methodName.c_str());
bool fullTrust = env->CallBooleanMethod(obj, getFullTrust);
bool isSingleton = env->CallBooleanMethod(obj, getIsSingleton);
bool log = env->CallBooleanMethod(obj, getLog);
bool notifyEvents = env->CallBooleanMethod(obj, getNotifyEvents);
MonoObject* exception = NULL;
void* args[1];
args[0] = assemblyName;
mono_runtime_invoke(setAssemblyNameField, processRequest, args, &exception);
args[0] = assemblyPath;
mono_runtime_invoke(setAssemblyPathField, processRequest, args, &exception);
args[0] = methodName;
mono_runtime_invoke(setMethodNameField, processRequest, args, &exception);
args[0] = &fullTrust;
mono_runtime_invoke(setFullTrustField, processRequest, args, &exception);
args[0] = &log;
mono_runtime_invoke(setLogField, processRequest, args, &exception);
args[0] = &isSingleton;
mono_runtime_invoke(setIsSingletonField, processRequest, args, &exception);
args[0] = ¬ifyEvents;
mono_runtime_invoke(setNotifyEventsField, processRequest, args, &exception);
if (exception)
{
const char* message = mono_string_to_utf8(mono_object_to_string(exception, NULL));
throwException(message);
}
jobject javaMethodArguments = env->CallObjectMethod(obj, getMethodArguments);
setProperties(env, javaMethodArguments, addMethodArgumentsProperty, processRequest);
//request->MethodArguments = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getMethodArguments));
//request->InboundProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getInboundProperties));
//request->InvocationProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getInvocationProperties));
//request->OutboundProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getOutboundProperties));
//request->SessionProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getSessionProperties));
}
MonoObject* ml_invoke(MonoMethod *method, void *obj, void **params)
{
MonoObject *ret, *exception;
ret = mono_runtime_invoke(method, obj, params, &exception);
if (exception) {
purple_debug(PURPLE_DEBUG_ERROR, "mono", "caught exception: %s\n", mono_class_get_name(mono_object_get_class(exception)));
}
return ret;
}
void Application::FireOnReload()
{
for (auto& obj : instances) {
auto klass = mono_object_get_class(obj);
if (klass) {
auto method = find_method(klass, "OnReload");
if (method)
mono_runtime_invoke(method, obj, NULL, NULL);
}
}
}
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");
}
mono::object CScriptMethod::Invoke(mono::object object, void **pParams, int numParams)
{
MonoObject *pException = nullptr;
MonoObject *pResult = mono_runtime_invoke(m_pMonoMethod, object, pParams, &pException);
if(pException)
CScriptObject::HandleException(pException);
else if(pResult)
return (mono::object)pResult;
return nullptr;
}
MonoObject* NodejsFunc::GetFunc()
{
static MonoMethod* method;
if (!method)
method = mono_class_get_method_from_name(GetNodejsFuncClass(), "GetFunc", -1);
MonoException* exc = NULL;
MonoObject* func = mono_runtime_invoke(method, mono_gchandle_get_target(_this), NULL, (MonoObject**)&exc);
return func;
}
MonoString* MonoEmbedding::TryConvertPrimitiveOrDecimal(MonoObject* obj, MonoException** exc)
{
static MonoMethod* method;
*exc = NULL;
if (!method)
method = mono_class_get_method_from_name(MonoEmbedding::GetClass(), "TryConvertPrimitiveOrDecimal", -1);
void* args[] = { obj };
return (MonoString*)mono_runtime_invoke(method, NULL, args, (MonoObject**)exc);
}
MonoString* MonoEmbedding::ToString(MonoObject* o, MonoException** exc)
{
static MonoMethod* method;
*exc = NULL;
if (!method)
method = mono_class_get_method_from_name(MonoEmbedding::GetClass(), "ObjectToString", -1);
void* args[] = { o };
return (MonoString*)mono_runtime_invoke(method, NULL, args, (MonoObject**)exc);
}
MonoClass* MonoEmbedding::GetFuncClass()
{
static MonoMethod* method;
MonoException* exc = NULL;
if (!method)
method = mono_class_get_method_from_name(MonoEmbedding::GetClass(), "GetFuncType", -1);
MonoReflectionType* typeObject = (MonoReflectionType*)mono_runtime_invoke(method, NULL, NULL, (MonoObject**)&exc);
MonoType* type = mono_reflection_type_get_type(typeObject);
MonoClass* klass = mono_class_from_mono_type(type);
return klass;
}
G_MODULE_EXPORT void
theme_exit ()
{
MaigreMonoBridge *bridge = maigre_mono_bridge ();
MonoClass *klass;
MonoMethod *method;
if (bridge != NULL &&
(klass = mono_class_from_name (bridge->image, "Maigre", "ThemeModule")) != NULL &&
(method = mono_class_get_method_from_name (klass, "Exit", 0)) != NULL) {
mono_runtime_invoke (method, NULL, NULL, NULL);
}
}
MonoObject* MonoEmbedding::CreateExpandoObject()
{
static MonoMethod* method;
MonoException* exc = NULL;
if (!method)
{
method = mono_class_get_method_from_name(MonoEmbedding::GetClass(), "CreateExpandoObject", -1);
}
MonoObject* dictionary = mono_runtime_invoke(method, NULL, NULL, (MonoObject**)&exc);
return dictionary;
}
void MonoEmbedding::ContinueTask(MonoObject* task, MonoObject* state, MonoException** exc)
{
static MonoMethod* method;
*exc = NULL;
if (!method)
method = mono_class_get_method_from_name(MonoEmbedding::GetClass(), "ContinueTask", -1);
void* args[2];
args[0] = task;
args[1] = state;
mono_runtime_invoke(method, NULL, args, (MonoObject**)exc);
}
void JniManager::setProperties(JNIEnv* env, jobject map, MonoMethod* method, MonoObject* instance)
{
assert(env);
MonoDomain* monoDomain = getMonoDomain();
if (map == NULL)
{
return;
}
int mapSize = env->CallIntMethod(map, typeConverter->size);
jobject keys = env->CallObjectMethod(map, typeConverter->keySet);
jobjectArray arrayOfKeys = (jobjectArray)env->CallObjectMethod(keys, typeConverter->toArray);
for (int i = 0; i < mapSize; i++)
{
jstring javaKeyName = (jstring)env->GetObjectArrayElement(arrayOfKeys, i);
string keyName = typeConverter->convertToC<string>(env, javaKeyName);
jobject mapValue = env->CallObjectMethod(map, typeConverter->getMapValue, javaKeyName);
//if (env->IsInstanceOf(mapValue, typeConverter->mapClazz))
//{
//}
MonoObject* exc = NULL;
void* args[2];
args[0] = mono_string_new(monoDomain, keyName.c_str());
args[1] = toMonoObject(env, mapValue);
mono_runtime_invoke(method, instance, args, &exc);
if (exc)
{
const char* message = mono_string_to_utf8(mono_object_to_string(exc, NULL));
throwException(message);
return;
}
env->DeleteLocalRef(javaKeyName);
env->DeleteLocalRef(mapValue);
}
env->DeleteLocalRef(keys);
env->DeleteLocalRef(arrayOfKeys);
env->DeleteLocalRef(map);
}
void
mono_threadpool_ms_enqueue_work_item (MonoDomain *domain, MonoObject *work_item)
{
static MonoClass *threadpool_class = NULL;
static MonoMethod *unsafe_queue_custom_work_item_method = NULL;
MonoDomain *current_domain;
MonoBoolean f;
gpointer args [2];
g_assert (work_item);
if (!threadpool_class)
threadpool_class = mono_class_from_name (mono_defaults.corlib, "System.Threading", "ThreadPool");
g_assert (threadpool_class);
if (!unsafe_queue_custom_work_item_method)
unsafe_queue_custom_work_item_method = mono_class_get_method_from_name (threadpool_class, "UnsafeQueueCustomWorkItem", 2);
g_assert (unsafe_queue_custom_work_item_method);
f = FALSE;
args [0] = (gpointer) work_item;
args [1] = (gpointer) mono_value_box (domain, mono_defaults.boolean_class, &f);
current_domain = mono_domain_get ();
if (current_domain == domain) {
mono_runtime_invoke (unsafe_queue_custom_work_item_method, NULL, args, NULL);
} else {
mono_thread_push_appdomain_ref (domain);
if (mono_domain_set (domain, FALSE)) {
mono_runtime_invoke (unsafe_queue_custom_work_item_method, NULL, args, NULL);
mono_domain_set (current_domain, TRUE);
}
mono_thread_pop_appdomain_ref ();
}
}
