static MonoType* mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve, MonoError *error);
/* Class lazy loading functions */
-static GENERATE_GET_CLASS_WITH_CACHE (mono_assembly, System.Reflection, MonoAssembly)
-static GENERATE_GET_CLASS_WITH_CACHE (mono_module, System.Reflection, MonoModule)
-static GENERATE_GET_CLASS_WITH_CACHE (mono_method, System.Reflection, MonoMethod);
-static GENERATE_GET_CLASS_WITH_CACHE (mono_cmethod, System.Reflection, MonoCMethod);
-static GENERATE_GET_CLASS_WITH_CACHE (mono_field, System.Reflection, MonoField);
-static GENERATE_GET_CLASS_WITH_CACHE (mono_event, System.Reflection, MonoEvent);
-static GENERATE_GET_CLASS_WITH_CACHE (mono_property, System.Reflection, MonoProperty);
-static GENERATE_GET_CLASS_WITH_CACHE (mono_parameter_info, System.Reflection, MonoParameterInfo);
-static GENERATE_GET_CLASS_WITH_CACHE (missing, System.Reflection, Missing);
-static GENERATE_GET_CLASS_WITH_CACHE (method_body, System.Reflection, MethodBody);
-static GENERATE_GET_CLASS_WITH_CACHE (local_variable_info, System.Reflection, LocalVariableInfo);
-static GENERATE_GET_CLASS_WITH_CACHE (exception_handling_clause, System.Reflection, ExceptionHandlingClause);
-static GENERATE_GET_CLASS_WITH_CACHE (type_builder, System.Reflection.Emit, TypeBuilder);
-static GENERATE_GET_CLASS_WITH_CACHE (dbnull, System, DBNull);
+static GENERATE_GET_CLASS_WITH_CACHE (mono_assembly, "System.Reflection", "MonoAssembly")
+static GENERATE_GET_CLASS_WITH_CACHE (mono_module, "System.Reflection", "MonoModule")
+static GENERATE_GET_CLASS_WITH_CACHE (mono_method, "System.Reflection", "MonoMethod");
+static GENERATE_GET_CLASS_WITH_CACHE (mono_cmethod, "System.Reflection", "MonoCMethod");
+static GENERATE_GET_CLASS_WITH_CACHE (mono_field, "System.Reflection", "MonoField");
+static GENERATE_GET_CLASS_WITH_CACHE (mono_event, "System.Reflection", "MonoEvent");
+static GENERATE_GET_CLASS_WITH_CACHE (mono_property, "System.Reflection", "MonoProperty");
+static GENERATE_GET_CLASS_WITH_CACHE (mono_parameter_info, "System.Reflection", "MonoParameterInfo");
+static GENERATE_GET_CLASS_WITH_CACHE (missing, "System.Reflection", "Missing");
+static GENERATE_GET_CLASS_WITH_CACHE (method_body, "System.Reflection", "MethodBody");
+static GENERATE_GET_CLASS_WITH_CACHE (local_variable_info, "System.Reflection", "LocalVariableInfo");
+static GENERATE_GET_CLASS_WITH_CACHE (exception_handling_clause, "System.Reflection", "ExceptionHandlingClause");
+static GENERATE_GET_CLASS_WITH_CACHE (type_builder, "System.Reflection.Emit", "TypeBuilder");
+static GENERATE_GET_CLASS_WITH_CACHE (dbnull, "System", "DBNull");
static int class_ref_info_handle_count;
*
* Return the type builder/generic param builder corresponding to KLASS, if it exists.
*/
-gpointer
+MonoObjectHandle
mono_class_get_ref_info (MonoClass *klass)
{
MONO_REQ_GC_UNSAFE_MODE;
guint32 ref_info_handle = mono_class_get_ref_info_handle (klass);
+ if (ref_info_handle == 0)
+ return MONO_HANDLE_NEW (MonoObject, NULL);
+ else
+ return mono_gchandle_get_target_handle (ref_info_handle);
+}
+
+gboolean
+mono_class_has_ref_info (MonoClass *klass)
+{
+ MONO_REQ_GC_UNSAFE_MODE;
+ return 0 != mono_class_get_ref_info_handle (klass);
+}
+
+MonoObject*
+mono_class_get_ref_info_raw (MonoClass *klass)
+{
+ /* FIXME callers of mono_class_get_ref_info_raw should use handles */
+ MONO_REQ_GC_UNSAFE_MODE;
+ guint32 ref_info_handle = mono_class_get_ref_info_handle (klass);
+
if (ref_info_handle == 0)
return NULL;
else
}
void
-mono_class_set_ref_info (MonoClass *klass, gpointer obj)
+mono_class_set_ref_info (MonoClass *klass, MonoObjectHandle obj)
{
MONO_REQ_GC_UNSAFE_MODE;
- guint32 candidate = mono_gchandle_new ((MonoObject*)obj, FALSE);
+ guint32 candidate = mono_gchandle_from_handle (obj, FALSE);
guint32 handle = mono_class_set_ref_info_handle (klass, candidate);
++class_ref_info_handle_count;
guint
reflected_hash (gconstpointer a) {
const ReflectedEntry *ea = (const ReflectedEntry *)a;
- return mono_aligned_addr_hash (ea->item);
+ /* Combine hashes for item and refclass. Identical to boost's hash_combine */
+ guint seed = mono_aligned_addr_hash (ea->item) + 0x9e3779b9;
+ seed ^= mono_aligned_addr_hash (ea->refclass) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+ return seed;
}
static MonoReflectionAssemblyHandle
assembly_object_construct (MonoDomain *domain, MonoClass *unused_klass, MonoAssembly *assembly, gpointer user_data, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoReflectionAssemblyHandle res = MONO_HANDLE_NEW (MonoReflectionAssembly, mono_object_new_checked (domain, mono_class_get_mono_assembly_class (), error));
return_val_if_nok (error, MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE));
MONO_HANDLE_SETVAL (res, assembly, MonoAssembly*, assembly);
MonoReflectionAssemblyHandle
mono_assembly_get_object_handle (MonoDomain *domain, MonoAssembly *assembly, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionAssemblyHandle, assembly, NULL, assembly_object_construct, NULL);
}
{
char* basename;
- mono_error_init (error);
+ error_init (error);
MonoReflectionModuleHandle res = MONO_HANDLE_NEW (MonoReflectionModule, mono_object_new_checked (domain, mono_class_get_mono_module_class (), error));
if (!is_ok (error))
goto fail;
MonoReflectionModuleHandle
mono_module_get_object_handle (MonoDomain *domain, MonoImage *image, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionModuleHandle, image, NULL, module_object_construct, NULL);
}
guint32 i, name_idx;
const char *val;
- mono_error_init (error);
+ error_init (error);
MonoReflectionModuleHandle res = MONO_HANDLE_NEW (MonoReflectionModule, mono_object_new_checked (domain, mono_class_get_mono_module_class (), error));
if (!is_ok (error))
MonoReflectionType *res;
MonoClass *klass;
- mono_error_init (error);
+ error_init (error);
g_assert (type != NULL);
klass = mono_class_from_mono_type (type);
return NULL;
}
- if (mono_class_get_ref_info (klass) && !klass->wastypebuilder && !type->byref) {
+ if (mono_class_has_ref_info (klass) && !klass->wastypebuilder && !type->byref) {
mono_domain_unlock (domain);
mono_loader_unlock ();
- return (MonoReflectionType *)mono_class_get_ref_info (klass);
+ return (MonoReflectionType *)mono_class_get_ref_info_raw (klass); /* FIXME use handles */
}
/* This is stored in vtables/JITted code so it has to be pinned */
res = (MonoReflectionType *)mono_object_new_pinned (domain, mono_defaults.runtimetype_class, error);
static MonoReflectionMethodHandle
method_object_construct (MonoDomain *domain, MonoClass *refclass, MonoMethod *method, gpointer user_data, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
g_assert (refclass != NULL);
/*
* We use the same C representation for methods and constructors, but the type
*/
MonoClass *klass;
- mono_error_init (error);
+ error_init (error);
if (*method->name == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0)) {
klass = mono_class_get_mono_cmethod_class ();
MonoReflectionMethodHandle
mono_method_get_object_handle (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (!refclass)
refclass = method->klass;
static MonoReflectionFieldHandle
field_object_construct (MonoDomain *domain, MonoClass *klass, MonoClassField *field, gpointer user_data, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoReflectionFieldHandle res = MONO_HANDLE_NEW (MonoReflectionField, mono_object_new_checked (domain, mono_class_get_mono_field_class (), error));
if (!is_ok (error))
MonoReflectionFieldHandle
mono_field_get_object_handle (MonoDomain *domain, MonoClass *klass, MonoClassField *field, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionFieldHandle, field, klass, field_object_construct, NULL);
}
static MonoReflectionPropertyHandle
property_object_construct (MonoDomain *domain, MonoClass *klass, MonoProperty *property, gpointer user_data, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoReflectionPropertyHandle res = MONO_HANDLE_NEW (MonoReflectionProperty, mono_object_new_checked (domain, mono_class_get_mono_property_class (), error));
if (!is_ok (error))
event_object_construct (MonoDomain *domain, MonoClass *klass, MonoEvent *event, gpointer user_data, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoReflectionMonoEventHandle mono_event = MONO_HANDLE_NEW (MonoReflectionMonoEvent, mono_object_new_checked (domain, mono_class_get_mono_event_class (), error));
if (!is_ok (error))
return MONO_HANDLE_CAST (MonoReflectionEvent, NULL_HANDLE);
MonoReflectionEventHandle
mono_event_get_object_handle (MonoDomain *domain, MonoClass *klass, MonoEvent *event, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionEventHandle, event, klass, event_object_construct, NULL);
}
{
static MonoClassField *dbnull_value_field = NULL;
- mono_error_init (error);
+ error_init (error);
if (!dbnull_value_field) {
MonoClass *dbnull_klass;
static MonoObjectHandle
get_dbnull (MonoDomain *domain, MonoObjectHandle dbnull, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (MONO_HANDLE_IS_NULL (dbnull))
MONO_HANDLE_ASSIGN (dbnull, get_dbnull_object (domain, error));
return dbnull;
add_parameter_object_to_array (MonoDomain *domain, MonoMethod *method, MonoObjectHandle member, int idx, const char *name, MonoType *sig_param, guint32 blob_type_enum, const char *blob, MonoMarshalSpec *mspec, MonoObjectHandle missing, MonoObjectHandle dbnull, MonoArrayHandle dest, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoReflectionParameterHandle param = MONO_HANDLE_NEW (MonoReflectionParameter, mono_object_new_checked (domain, mono_class_get_mono_parameter_info_class (), error));
if (!is_ok (error))
goto leave;
MonoMarshalSpec **mspecs = NULL;
int i;
- mono_error_init (error);
+ error_init (error);
MonoReflectionMethodHandle member = mono_method_get_object_handle (domain, method, refclass, error);
if (!is_ok (error))
MonoArrayHandle
mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
/* side-effect: sets method->signature non-NULL on success */
MonoMethodSignature *sig = mono_method_signature_checked (method, error);
add_local_var_info_to_array (MonoDomain *domain, MonoMethodHeader *header, int idx, MonoArrayHandle dest, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoReflectionLocalVariableInfoHandle info = MONO_HANDLE_NEW (MonoReflectionLocalVariableInfo, mono_object_new_checked (domain, mono_class_get_local_variable_info_class (), error));
if (!is_ok (error))
goto leave;
add_exception_handling_clause_to_array (MonoDomain *domain, MonoMethodHeader *header, int idx, MonoArrayHandle dest, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoReflectionExceptionHandlingClauseHandle info = MONO_HANDLE_NEW (MonoReflectionExceptionHandlingClause, mono_object_new_checked (domain, mono_class_get_exception_handling_clause_class (), error));
if (!is_ok (error))
goto leave;
unsigned char format, flags;
int i;
- mono_error_init (error);
+ error_init (error);
/* for compatibility with .net */
if (method_is_dynamic (method)) {
MonoReflectionMethodBodyHandle
mono_method_body_get_object_handle (MonoDomain *domain, MonoMethod *method, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionMethodBodyHandle, method, NULL, method_body_object_construct, NULL);
}
MonoObject *object;
MonoType *basetype = type;
- mono_error_init (error);
+ error_init (error);
if (!blob)
return NULL;
MonoType *type;
MonoImage *rootimage = image;
- mono_error_init (error);
+ error_init (error);
if (info->assembly.name) {
MonoAssembly *assembly = mono_assembly_loaded (&info->assembly);
if (type == NULL && !info->assembly.name && image != mono_defaults.corlib) {
/* ignore the error and try again */
mono_error_cleanup (error);
- mono_error_init (error);
+ error_init (error);
image = mono_defaults.corlib;
type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve, error);
}
int modval;
gboolean bounded = FALSE;
- mono_error_init (error);
+ error_init (error);
if (!image)
image = mono_defaults.corlib;
if (info->type_arguments) {
MonoType **type_args = g_new0 (MonoType *, info->type_arguments->len);
- MonoReflectionType *the_type;
+ MonoReflectionTypeHandle the_type;
MonoType *instance;
int i;
}
}
- the_type = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, error);
- if (!the_type)
+ the_type = mono_type_get_object_handle (mono_domain_get (), &klass->byval_arg, error);
+ if (!is_ok (error) || MONO_HANDLE_IS_NULL (the_type))
return NULL;
instance = mono_reflection_bind_generic_parameters (
*/
MonoType*
mono_reflection_get_type_checked (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve, MonoError *error) {
- mono_error_init (error);
+ error_init (error);
return mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, type_resolve, error);
}
module_builder_array_get_type (MonoArrayHandle module_builders, int i, MonoImage *rootimage, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoType *type = NULL;
MonoReflectionModuleBuilderHandle mb = MONO_HANDLE_NEW (MonoReflectionModuleBuilder, NULL);
MONO_HANDLE_ARRAY_GETREF (mb, module_builders, i);
module_array_get_type (MonoArrayHandle modules, int i, MonoImage *rootimage, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoType *type = NULL;
MonoReflectionModuleHandle mod = MONO_HANDLE_NEW (MonoReflectionModule, NULL);
MONO_HANDLE_ARRAY_GETREF (mod, modules, i);
MonoType *type = NULL;
int i;
- mono_error_init (error);
+ error_init (error);
g_assert (assembly_is_dynamic (assembly));
MonoReflectionAssemblyBuilderHandle abuilder = MONO_HANDLE_CAST (MonoReflectionAssemblyBuilder, mono_assembly_get_object_handle (((MonoDynamicAssembly*)assembly)->domain, assembly, error));
if (!is_ok (error))
GString *fullName;
GList *mod;
- mono_error_init (error);
+ error_init (error);
if (image && image_is_dynamic (image))
type = mono_reflection_get_type_internal_dynamic (rootimage, image->assembly, info, ignorecase, error);
MonoTypeNameParse info;
char *tmp;
- mono_error_init (error);
+ error_init (error);
/* Make a copy since parse_type modifies its argument */
tmp = g_strdup (name);
{
guint32 token = 0;
- mono_error_init (error);
+ error_init (error);
MonoClass *klass = mono_handle_class (obj);
gboolean
-mono_reflection_is_usertype (MonoReflectionType *ref)
+mono_reflection_is_usertype (MonoReflectionTypeHandle ref)
{
- MonoClass *klass = mono_object_class (ref);
+ MonoClass *klass = mono_handle_class (ref);
return klass->image != mono_defaults.corlib || strcmp ("TypeDelegator", klass->name) == 0;
}
* Returns the MonoType* for the resulting type instantiation. On failure returns NULL and sets @error.
*/
MonoType*
-mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types, MonoError *error)
+mono_reflection_bind_generic_parameters (MonoReflectionTypeHandle reftype, int type_argc, MonoType **types, MonoError *error)
{
- MonoClass *klass;
gboolean is_dynamic = FALSE;
MonoClass *geninst;
- mono_error_init (error);
+ error_init (error);
mono_loader_lock ();
- if (mono_is_sre_type_builder (mono_object_class (type))) {
+ MonoClass *klass = mono_handle_class (reftype);
+ if (mono_is_sre_type_builder (klass)) {
is_dynamic = TRUE;
- } else if (mono_is_sre_generic_instance (mono_object_class (type))) {
+ } else if (mono_is_sre_generic_instance (klass)) {
/* Does this ever make sense? what does instantiating a generic instance even mean? */
g_assert_not_reached ();
- MonoReflectionGenericClass *rgi = (MonoReflectionGenericClass *) type;
- MonoReflectionType *gtd = rgi->generic_type;
+ MonoReflectionGenericClassHandle rgi = MONO_HANDLE_CAST (MonoReflectionGenericClass, reftype);
+ MonoReflectionTypeHandle gtd = MONO_HANDLE_NEW_GET (MonoReflectionType, rgi, generic_type);
- if (mono_is_sre_type_builder (mono_object_class (gtd)))
+ if (mono_is_sre_type_builder (mono_handle_class (gtd)))
is_dynamic = TRUE;
}
- MonoType *t = mono_reflection_type_get_handle (type, error);
+ MonoType *t = mono_reflection_type_handle_mono_type (reftype, error);
if (!is_ok (error)) {
mono_loader_unlock ();
return NULL;
return mono_generic_class_get_class (gclass);
}
-static MonoReflectionMethod*
-reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, MonoArray *types, MonoError *error)
+static MonoGenericInst*
+generic_inst_from_type_array_handle (MonoArrayHandle types, MonoError *error)
{
- MonoClass *klass;
- MonoMethod *method, *inflated;
- MonoMethodInflated *imethod;
- MonoGenericContext tmp_context;
- MonoGenericInst *ginst;
- MonoType **type_argv;
- int count, i;
+ HANDLE_FUNCTION_ENTER ();
+ error_init (error);
+ MonoGenericInst *ginst = NULL;
+ int count = mono_array_handle_length (types);
+ MonoType **type_argv = g_new0 (MonoType *, count);
+ MonoReflectionTypeHandle garg = MONO_HANDLE_NEW (MonoReflectionType, NULL);
+ for (int i = 0; i < count; i++) {
+ MONO_HANDLE_ARRAY_GETREF (garg, types, i);
+ type_argv [i] = mono_reflection_type_handle_mono_type (garg, error);
+ if (!is_ok (error))
+ goto leave;
- mono_error_init (error);
+ }
+ ginst = mono_metadata_get_generic_inst (count, type_argv);
+leave:
+ g_free (type_argv);
+ HANDLE_FUNCTION_RETURN_VAL (ginst);
+}
- g_assert (strcmp (rmethod->object.vtable->klass->name, "MethodBuilder"));
+static MonoMethod*
+reflection_bind_generic_method_parameters (MonoMethod *method, MonoArrayHandle types, MonoError *error)
+{
+ MonoClass *klass;
+ MonoMethod *inflated;
+ MonoGenericContext tmp_context;
- method = rmethod->method;
+ error_init (error);
klass = method->klass;
if (method->is_inflated)
method = ((MonoMethodInflated *) method)->declaring;
- count = mono_method_signature (method)->generic_param_count;
- if (count != mono_array_length (types))
+ int count = mono_method_signature (method)->generic_param_count;
+ if (count != mono_array_handle_length (types)) {
+ mono_error_set_argument (error, "typeArguments", "Incorrect number of generic arguments");
return NULL;
-
- type_argv = g_new0 (MonoType *, count);
- for (i = 0; i < count; i++) {
- MonoReflectionType *garg = (MonoReflectionType *)mono_array_get (types, gpointer, i);
- type_argv [i] = mono_reflection_type_get_handle (garg, error);
- if (!is_ok (error)) {
- g_free (type_argv);
- return NULL;
- }
}
- ginst = mono_metadata_get_generic_inst (count, type_argv);
- g_free (type_argv);
+
+ MonoGenericInst *ginst = generic_inst_from_type_array_handle (types, error);
+ return_val_if_nok (error, NULL);
tmp_context.class_inst = mono_class_is_ginst (klass) ? mono_class_get_generic_class (klass)->context.class_inst : NULL;
tmp_context.method_inst = ginst;
inflated = mono_class_inflate_generic_method_checked (method, &tmp_context, error);
mono_error_assert_ok (error);
- imethod = (MonoMethodInflated *) inflated;
+
+ if (!mono_verifier_is_method_valid_generic_instantiation (inflated)) {
+ mono_error_set_argument (error, "typeArguments", "Invalid generic arguments");
+ return NULL;
+ }
+
+ return inflated;
+}
+
+MonoReflectionMethodHandle
+ves_icall_MonoMethod_MakeGenericMethod_impl (MonoReflectionMethodHandle rmethod, MonoArrayHandle types, MonoError *error)
+{
+ error_init (error);
+ g_assert (0 != strcmp (mono_handle_class (rmethod)->name, "MethodBuilder"));
+
+ MonoMethod *method = MONO_HANDLE_GETVAL (rmethod, method);
+ MonoMethod *imethod = reflection_bind_generic_method_parameters (method, types, error);
+ return_val_if_nok (error, MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE));
/*FIXME but I think this is no longer necessary*/
if (image_is_dynamic (method->klass->image)) {
* to the reflection objects representing their generic definitions.
*/
mono_image_lock ((MonoImage*)image);
- mono_g_hash_table_insert (image->generic_def_objects, imethod, rmethod);
+ mono_g_hash_table_insert (image->generic_def_objects, imethod, MONO_HANDLE_RAW (rmethod));
mono_image_unlock ((MonoImage*)image);
}
- if (!mono_verifier_is_method_valid_generic_instantiation (inflated)) {
- mono_error_set_argument (error, "typeArguments", "Invalid generic arguments");
- return NULL;
- }
-
- return mono_method_get_object_checked (mono_object_domain (rmethod), inflated, NULL, error);
-}
-
-MonoReflectionMethod*
-ves_icall_MonoMethod_MakeGenericMethod_impl (MonoReflectionMethod *rmethod, MonoArray *types)
-{
- MonoError error;
- MonoReflectionMethod *result = reflection_bind_generic_method_parameters (rmethod, types, &error);
- mono_error_set_pending_exception (&error);
- return result;
+ return mono_method_get_object_handle (MONO_HANDLE_DOMAIN (rmethod), imethod, NULL, error);
}
void *params [1];
static MonoMethod *method = NULL;
- mono_error_init (error);
+ error_init (error);
if (method == NULL) {
method = mono_class_get_method_from_name (mono_class_get_type_builder_class (), "IsAssignableTo", 1);
* The result of mono_type_get_object_checked () might be a System.MonoType but we
* need a TypeBuilder so use mono_class_get_ref_info (klass).
*/
- g_assert (mono_class_get_ref_info (klass));
- g_assert (!strcmp (((MonoObject*)(mono_class_get_ref_info (klass)))->vtable->klass->name, "TypeBuilder"));
+ g_assert (mono_class_has_ref_info (klass));
+ g_assert (!strcmp (mono_object_class (mono_class_get_ref_info_raw (klass))->name, "TypeBuilder")); /* FIXME use handles */
params [0] = mono_type_get_object_checked (mono_domain_get (), &oklass->byval_arg, error);
return_val_if_nok (error, FALSE);
MonoError inner_error;
- res = mono_runtime_try_invoke (method, (MonoObject*)(mono_class_get_ref_info (klass)), params, &exc, &inner_error);
+ res = mono_runtime_try_invoke (method, mono_class_get_ref_info_raw (klass), params, &exc, &inner_error); /* FIXME use handles */
if (exc || !is_ok (&inner_error)) {
mono_error_cleanup (&inner_error);
projects / mono.git / blobdiff