MonoException * mono_get_exception_runtime_wrapped_checked (MonoObject *wrapped_exception, MonoError *error) { MonoClass *klass; MonoObject *o; MonoMethod *method; MonoDomain *domain = mono_domain_get (); gpointer params [16]; klass = mono_class_load_from_name (mono_get_corlib (), "System.Runtime.CompilerServices", "RuntimeWrappedException"); o = mono_object_new_checked (domain, klass, error); mono_error_assert_ok (error); g_assert (o != NULL); method = mono_class_get_method_from_name (klass, ".ctor", 1); g_assert (method); params [0] = wrapped_exception; mono_runtime_invoke_checked (method, o, params, error); return_val_if_nok (error, NULL); return (MonoException *)o; }
MonoException * mono_get_exception_runtime_wrapped (MonoObject *wrapped_exception) { MonoError error; MonoClass *klass; MonoObject *o; MonoMethod *method; MonoDomain *domain = mono_domain_get (); gpointer params [16]; klass = mono_class_load_from_name (mono_get_corlib (), "System.Runtime.CompilerServices", "RuntimeWrappedException"); o = mono_object_new_checked (domain, klass, &error); g_assert (o != NULL && mono_error_ok (&error)); /* FIXME don't swallow the error */ method = mono_class_get_method_from_name (klass, ".ctor", 1); g_assert (method); params [0] = wrapped_exception; mono_runtime_invoke_checked (method, o, params, &error); mono_error_raise_exception (&error); /* FIXME don't raise here */ return (MonoException *)o; }
void invoke_protected_memory_method (MonoArray *data, MonoObject *scope, gboolean encrypt, MonoError *error) { MonoClass *klass; MonoMethod *method; void *params [2]; mono_error_init (error); 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_load_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_checked (method, NULL, params, error); }
static MonoException * create_exception_two_strings (MonoClass *klass, MonoString *a1, MonoString *a2) { MonoError error; MonoDomain *domain = mono_domain_get (); MonoMethod *method = NULL; MonoObject *o; int count = 1; gpointer args [2]; gpointer iter; MonoMethod *m; if (a2 != NULL) count++; o = mono_object_new_checked (domain, klass, &error); mono_error_assert_ok (&error); iter = NULL; while ((m = mono_class_get_methods (klass, &iter))) { MonoMethodSignature *sig; if (strcmp (".ctor", mono_method_get_name (m))) continue; sig = mono_method_signature (m); if (sig->param_count != count) continue; if (sig->params [0]->type != MONO_TYPE_STRING) continue; if (count == 2 && sig->params [1]->type != MONO_TYPE_STRING) continue; method = m; break; } args [0] = a1; args [1] = a2; mono_runtime_invoke_checked (method, o, args, &error); mono_error_raise_exception (&error); /* FIXME don't raise here */ return (MonoException *) o; }
MonoExceptionHandle mono_get_exception_reflection_type_load_checked (MonoArrayHandle types, MonoArrayHandle exceptions, MonoError *error) { HANDLE_FUNCTION_ENTER (); MonoClass *klass; MonoMethod *method; gpointer iter; error_init (error); klass = mono_class_load_from_name (mono_get_corlib (), "System.Reflection", "ReflectionTypeLoadException"); mono_class_init_internal (klass); /* Find the Type[], Exception[] ctor */ iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (!strcmp (".ctor", mono_method_get_name (method))) { MonoMethodSignature *sig = mono_method_signature_internal (method); if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_SZARRAY && sig->params [1]->type == MONO_TYPE_SZARRAY) break; } method = NULL; } g_assert (method); MonoExceptionHandle exc = MONO_HANDLE_CAST (MonoException, MONO_HANDLE_NEW (MonoObject, mono_object_new_checked (mono_domain_get (), klass, error))); mono_error_assert_ok (error); gpointer args [ ] = { MONO_HANDLE_RAW (types), MONO_HANDLE_RAW (exceptions) }; mono_runtime_invoke_checked (method, MONO_HANDLE_RAW (exc), args, error); goto_if_nok (error, return_null); goto exit; return_null: exc = MONO_HANDLE_CAST (MonoException, mono_new_null ()); exit: HANDLE_FUNCTION_RETURN_REF (MonoException, exc); }
/** * mono_get_exception_reflection_type_load: * @types: an array of types that were defined in the moduled loaded. * @exceptions: an array of exceptions that were thrown during the type loading. * * Returns: a new instance of the `System.Reflection.ReflectionTypeLoadException` */ MonoException * mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions) { MonoError error; MonoClass *klass; gpointer args [2]; MonoObject *exc; MonoMethod *method; gpointer iter; klass = mono_class_load_from_name (mono_get_corlib (), "System.Reflection", "ReflectionTypeLoadException"); mono_class_init (klass); /* Find the Type[], Exception[] ctor */ iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (!strcmp (".ctor", mono_method_get_name (method))) { MonoMethodSignature *sig = mono_method_signature (method); if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_SZARRAY && sig->params [1]->type == MONO_TYPE_SZARRAY) break; } method = NULL; } g_assert (method); args [0] = types; args [1] = exceptions; exc = mono_object_new_checked (mono_domain_get (), klass, &error); mono_error_assert_ok (&error); mono_runtime_invoke_checked (method, exc, args, &error); mono_error_raise_exception (&error); /* FIXME don't raise here */ return (MonoException *) exc; }
/** * 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) { MonoError error; MonoClass *klass; gpointer args [2]; MonoObject *exc; MonoMethod *method; gpointer iter; klass = mono_class_load_from_name (mono_get_corlib (), "System", "TypeInitializationException"); mono_class_init (klass); iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (!strcmp (".ctor", mono_method_get_name (method))) { MonoMethodSignature *sig = mono_method_signature (method); if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_STRING && mono_class_from_mono_type (sig->params [1]) == mono_defaults.exception_class) break; } method = NULL; } g_assert (method); args [0] = mono_string_new (mono_domain_get (), type_name); args [1] = inner; exc = mono_object_new_checked (mono_domain_get (), klass, &error); mono_error_assert_ok (&error); mono_runtime_invoke_checked (method, exc, args, &error); mono_error_raise_exception (&error); /* FIXME don't raise here */ return (MonoException *) exc; }