* [runtime] Remove MonoReflectionGenericMethod typedef.
- It's not used in the runtime,
- Unlike other defs in object-internals.h it doesn't seem to have a
corresponding managed object.
* [reflection] Add mono_field_get_object_handle.
Reimplement mono_field_get_object and mono_field_get_object_checked in
terms of it.
* [reflection] Add mono_property_get_object_handle
Reimplement mono_property_get_object and
mono_property_get_object_checked in terms of it.
* [reflection] Use handles for FieldInfo,MonoPropertyInfo,ParameterInfo.GetTypeModifiers
* [reflection] Use handles for MonoMethodInfo.get_parameter_info
- Change mono_param_get_objects_internal to use handles
* [reflection] Cleanup in method_object_construct
* [reflection] Use handles for System.Refleciton.EventInfo.internal_from_handle_type
- Replace mono_event_get_object_checked by mono_event_get_object_handle
which uses handles.
* [reflection] Use handles for System.Reflection.MethodBase.GetMethodBodyInternal
- Replace mono_method_body_get_object_checked by
mono_method_body_get_object_handle
* [reflection] Remove CHECK_OR_CONSTRUCT, it's dead code.
All former callers now use CHECK_OR_CONSTRUCT_HANDLE
* [reflection] Use handles for FieldInfo.get_marshal_info and MonoMethodInfo.get_retval_marshal
- Change mono_reflection_marshal_as_attribute_from_marshal_spec to
return a handle; fix callers
* [metadata] Add mono_metadata_get_canonical_generic_inst utility function
* [reflection] Use handles for System.Reflection.Module.ResolveMemberToken and 3 more icalls
- ResolveFieldToken
- ResolveMethodToken
- ResolveTypeToken
ICALL(TYPEB_1, "create_runtime_class", ves_icall_TypeBuilder_create_runtime_class)
ICALL_TYPE(EVENTI, "System.Reflection.EventInfo", EVENTI_1)
-ICALL(EVENTI_1, "internal_from_handle_type", ves_icall_System_Reflection_EventInfo_internal_from_handle_type)
+HANDLES(ICALL(EVENTI_1, "internal_from_handle_type", ves_icall_System_Reflection_EventInfo_internal_from_handle_type))
ICALL_TYPE(FIELDI, "System.Reflection.FieldInfo", FILEDI_1)
-ICALL(FILEDI_1, "GetTypeModifiers", ves_icall_System_Reflection_FieldInfo_GetTypeModifiers)
-ICALL(FILEDI_2, "get_marshal_info", ves_icall_System_Reflection_FieldInfo_get_marshal_info)
-ICALL(FILEDI_3, "internal_from_handle_type", ves_icall_System_Reflection_FieldInfo_internal_from_handle_type)
+HANDLES(ICALL(FILEDI_1, "GetTypeModifiers", ves_icall_System_Reflection_FieldInfo_GetTypeModifiers))
+HANDLES(ICALL(FILEDI_2, "get_marshal_info", ves_icall_System_Reflection_FieldInfo_get_marshal_info))
+HANDLES(ICALL(FILEDI_3, "internal_from_handle_type", ves_icall_System_Reflection_FieldInfo_internal_from_handle_type))
ICALL_TYPE(MEMBERI, "System.Reflection.MemberInfo", MEMBERI_1)
ICALL(MEMBERI_1, "get_MetadataToken", ves_icall_reflection_get_token)
ICALL_TYPE(MBASE, "System.Reflection.MethodBase", MBASE_1)
ICALL(MBASE_1, "GetCurrentMethod", ves_icall_GetCurrentMethod)
-ICALL(MBASE_2, "GetMethodBodyInternal", ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal)
+HANDLES(ICALL(MBASE_2, "GetMethodBodyInternal", ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal))
ICALL(MBASE_4, "GetMethodFromHandleInternalType_native", ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType_native)
ICALL_TYPE(MODULE, "System.Reflection.Module", MODULE_1)
HANDLES(ICALL(MODULE_4, "GetMDStreamVersion", ves_icall_System_Reflection_Module_GetMDStreamVersion))
HANDLES(ICALL(MODULE_5, "GetPEKind", ves_icall_System_Reflection_Module_GetPEKind))
HANDLES(ICALL(MODULE_6, "InternalGetTypes", ves_icall_System_Reflection_Module_InternalGetTypes))
-ICALL(MODULE_7, "ResolveFieldToken", ves_icall_System_Reflection_Module_ResolveFieldToken)
-ICALL(MODULE_8, "ResolveMemberToken", ves_icall_System_Reflection_Module_ResolveMemberToken)
-ICALL(MODULE_9, "ResolveMethodToken", ves_icall_System_Reflection_Module_ResolveMethodToken)
+HANDLES(ICALL(MODULE_7, "ResolveFieldToken", ves_icall_System_Reflection_Module_ResolveFieldToken))
+HANDLES(ICALL(MODULE_8, "ResolveMemberToken", ves_icall_System_Reflection_Module_ResolveMemberToken))
+HANDLES(ICALL(MODULE_9, "ResolveMethodToken", ves_icall_System_Reflection_Module_ResolveMethodToken))
ICALL(MODULE_10, "ResolveSignature", ves_icall_System_Reflection_Module_ResolveSignature)
ICALL(MODULE_11, "ResolveStringToken", ves_icall_System_Reflection_Module_ResolveStringToken)
-ICALL(MODULE_12, "ResolveTypeToken", ves_icall_System_Reflection_Module_ResolveTypeToken)
+HANDLES(ICALL(MODULE_12, "ResolveTypeToken", ves_icall_System_Reflection_Module_ResolveTypeToken))
ICALL(MODULE_13, "get_MetadataToken", ves_icall_reflection_get_token)
ICALL_TYPE(MCMETH, "System.Reflection.MonoCMethod", MCMETH_1)
ICALL_TYPE(MMETHI, "System.Reflection.MonoMethodInfo", MMETHI_4)
ICALL(MMETHI_4, "get_method_attributes", vell_icall_get_method_attributes)
ICALL(MMETHI_1, "get_method_info", ves_icall_get_method_info)
-ICALL(MMETHI_2, "get_parameter_info", ves_icall_get_parameter_info)
-ICALL(MMETHI_3, "get_retval_marshal", ves_icall_System_MonoMethodInfo_get_retval_marshal)
+HANDLES(ICALL(MMETHI_2, "get_parameter_info", ves_icall_System_Reflection_MonoMethodInfo_get_parameter_info))
+HANDLES(ICALL(MMETHI_3, "get_retval_marshal", ves_icall_System_MonoMethodInfo_get_retval_marshal))
ICALL_TYPE(MPROPI, "System.Reflection.MonoPropertyInfo", MPROPI_1)
-ICALL(MPROPI_1, "GetTypeModifiers", ves_icall_MonoPropertyInfo_GetTypeModifiers)
+HANDLES(ICALL(MPROPI_1, "GetTypeModifiers", ves_icall_MonoPropertyInfo_GetTypeModifiers))
ICALL(MPROPI_3, "get_default_value", property_info_get_default_value)
ICALL(MPROPI_2, "get_property_info", ves_icall_MonoPropertyInfo_get_property_info)
ICALL_TYPE(PARAMI, "System.Reflection.ParameterInfo", PARAMI_1)
ICALL(PARAMI_1, "GetMetadataToken", ves_icall_reflection_get_token)
-ICALL(PARAMI_2, "GetTypeModifiers", ves_icall_ParameterInfo_GetTypeModifiers)
+HANDLES(ICALL(PARAMI_2, "GetTypeModifiers", ves_icall_ParameterInfo_GetTypeModifiers))
ICALL_TYPE(PROPI, "System.Reflection.PropertyInfo", PROPI_1)
-ICALL(PROPI_1, "internal_from_handle_type", ves_icall_System_Reflection_PropertyInfo_internal_from_handle_type)
+HANDLES(ICALL(PROPI_1, "internal_from_handle_type", ves_icall_System_Reflection_PropertyInfo_internal_from_handle_type))
ICALL_TYPE(RTFIELD, "System.Reflection.RtFieldInfo", RTFIELD_1)
ICALL(RTFIELD_1, "UnsafeGetValue", ves_icall_MonoField_GetValueInternal)
static GENERATE_GET_CLASS_WITH_CACHE (event_info, System.Reflection, EventInfo)
static GENERATE_GET_CLASS_WITH_CACHE (module, System.Reflection, Module)
-static MonoArray*
+static MonoArrayHandle
type_array_from_modifiers (MonoImage *image, MonoType *type, int optional, MonoError *error);
static inline MonoBoolean
return mono_class_get_flags (klass);
}
-ICALL_EXPORT MonoReflectionMarshalAsAttribute*
-ves_icall_System_Reflection_FieldInfo_get_marshal_info (MonoReflectionField *field)
+ICALL_EXPORT MonoReflectionMarshalAsAttributeHandle
+ves_icall_System_Reflection_FieldInfo_get_marshal_info (MonoReflectionFieldHandle field_h, MonoError *error)
{
- MonoError error;
- MonoClass *klass = field->field->parent;
- MonoMarshalType *info;
- MonoType *ftype;
- int i;
+ mono_error_init (error);
+ MonoDomain *domain = MONO_HANDLE_DOMAIN (field_h);
+ MonoClassField *field = MONO_HANDLE_GETVAL (field_h, field);
+ MonoClass *klass = field->parent;
MonoGenericClass *gklass = mono_class_try_get_generic_class (klass);
if (mono_class_is_gtd (klass) ||
(gklass && gklass->context.class_inst->is_open))
- return NULL;
+ return MONO_HANDLE_CAST (MonoReflectionMarshalAsAttribute, NULL_HANDLE);
- ftype = mono_field_get_type (field->field);
+ MonoType *ftype = mono_field_get_type (field);
if (ftype && !(ftype->attrs & FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL))
- return NULL;
+ return MONO_HANDLE_CAST (MonoReflectionMarshalAsAttribute, NULL_HANDLE);
- info = mono_marshal_load_type_info (klass);
+ MonoMarshalType *info = mono_marshal_load_type_info (klass);
- for (i = 0; i < info->num_fields; ++i) {
- if (info->fields [i].field == field->field) {
+ for (int i = 0; i < info->num_fields; ++i) {
+ if (info->fields [i].field == field) {
if (!info->fields [i].mspec)
- return NULL;
+ return MONO_HANDLE_CAST (MonoReflectionMarshalAsAttribute, NULL_HANDLE);
else {
- MonoReflectionMarshalAsAttribute* obj;
- obj = mono_reflection_marshal_as_attribute_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec, &error);
- if (!mono_error_ok (&error))
- mono_error_set_pending_exception (&error);
- return obj;
+ return mono_reflection_marshal_as_attribute_from_marshal_spec (domain, klass, info->fields [i].mspec, error);
}
}
}
- return NULL;
+ return MONO_HANDLE_CAST (MonoReflectionMarshalAsAttribute, NULL_HANDLE);
}
-ICALL_EXPORT MonoReflectionField*
-ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (MonoClassField *handle, MonoType *type)
+ICALL_EXPORT MonoReflectionFieldHandle
+ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (MonoClassField *handle, MonoType *type, MonoError *error)
{
- MonoError error;
- gboolean found = FALSE;
MonoClass *klass;
g_assert (handle);
+ mono_error_init (error);
+
if (!type) {
klass = handle->parent;
} else {
klass = mono_class_from_mono_type (type);
- found = klass == handle->parent || mono_class_has_parent (klass, handle->parent);
+ gboolean found = klass == handle->parent || mono_class_has_parent (klass, handle->parent);
if (!found)
/* The managed code will throw the exception */
- return NULL;
+ return MONO_HANDLE_CAST (MonoReflectionField, NULL_HANDLE);
}
- MonoReflectionField *result = mono_field_get_object_checked (mono_domain_get (), klass, handle, &error);
- mono_error_set_pending_exception (&error);
- return result;
+ return mono_field_get_object_handle (mono_domain_get (), klass, handle, error);
}
-ICALL_EXPORT MonoReflectionEvent*
-ves_icall_System_Reflection_EventInfo_internal_from_handle_type (MonoEvent *handle, MonoType *type)
+ICALL_EXPORT MonoReflectionEventHandle
+ves_icall_System_Reflection_EventInfo_internal_from_handle_type (MonoEvent *handle, MonoType *type, MonoError *error)
{
- MonoError error;
MonoClass *klass;
g_assert (handle);
+ mono_error_init (error);
+
if (!type) {
klass = handle->parent;
} else {
gboolean found = klass == handle->parent || mono_class_has_parent (klass, handle->parent);
if (!found)
/* Managed code will throw an exception */
- return NULL;
+ return MONO_HANDLE_CAST (MonoReflectionEvent, NULL_HANDLE);
}
- MonoReflectionEvent *result = mono_event_get_object_checked (mono_domain_get (), klass, handle, &error);
- mono_error_set_pending_exception (&error);
- return result;
+ return mono_event_get_object_handle (mono_domain_get (), klass, handle, error);
}
-ICALL_EXPORT MonoReflectionProperty*
-ves_icall_System_Reflection_PropertyInfo_internal_from_handle_type (MonoProperty *handle, MonoType *type)
+ICALL_EXPORT MonoReflectionPropertyHandle
+ves_icall_System_Reflection_PropertyInfo_internal_from_handle_type (MonoProperty *handle, MonoType *type, MonoError *error)
{
- MonoError error;
+ mono_error_init (error);
MonoClass *klass;
g_assert (handle);
gboolean found = klass == handle->parent || mono_class_has_parent (klass, handle->parent);
if (!found)
/* Managed code will throw an exception */
- return NULL;
+ return MONO_HANDLE_CAST (MonoReflectionProperty, NULL_HANDLE);
}
- MonoReflectionProperty *result = mono_property_get_object_checked (mono_domain_get (), klass, handle, &error);
- mono_error_set_pending_exception (&error);
- return result;
+ return mono_property_get_object_handle (mono_domain_get (), klass, handle, error);
}
-ICALL_EXPORT MonoArray*
-ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionField *field, MonoBoolean optional)
+ICALL_EXPORT MonoArrayHandle
+ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionFieldHandle field_h, MonoBoolean optional, MonoError *error)
{
- MonoError error;
- MonoType *type = mono_field_get_type_checked (field->field, &error);
- MonoArray *res;
+ mono_error_init (error);
+ MonoClassField *field = MONO_HANDLE_GETVAL (field_h, field);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return NULL;
- }
+ MonoType *type = mono_field_get_type_checked (field, error);
+ if (!is_ok (error))
+ return MONO_HANDLE_CAST (MonoArray, NULL_HANDLE);
- res = type_array_from_modifiers (field->field->parent->image, type, optional, &error);
- mono_error_set_pending_exception (&error);
- return res;
+ return type_array_from_modifiers (field->parent->image, type, optional, error);
}
ICALL_EXPORT int
info->callconv |= (sig->hasthis << 5) | (sig->explicit_this << 6);
}
-ICALL_EXPORT MonoArray*
-ves_icall_get_parameter_info (MonoMethod *method, MonoReflectionMethod *member)
+ICALL_EXPORT MonoArrayHandle
+ves_icall_System_Reflection_MonoMethodInfo_get_parameter_info (MonoMethod *method, MonoReflectionMethodHandle member, MonoError *error)
{
- MonoError error;
+ mono_error_init (error);
MonoDomain *domain = mono_domain_get ();
- MonoArray *result = mono_param_get_objects_internal (domain, method, member->reftype ? mono_class_from_mono_type (member->reftype->type) : NULL, &error);
- mono_error_set_pending_exception (&error);
- return result;
+ MonoReflectionTypeHandle reftype = MONO_HANDLE_NEW (MonoReflectionType, NULL);
+ MONO_HANDLE_GET (reftype, member, reftype);
+ MonoClass *klass = NULL;
+ if (!MONO_HANDLE_IS_NULL (reftype))
+ klass = mono_class_from_mono_type (MONO_HANDLE_GETVAL (reftype, type));
+ return mono_param_get_objects_internal (domain, method, klass, error);
}
-ICALL_EXPORT MonoReflectionMarshalAsAttribute*
-ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method)
+ICALL_EXPORT MonoReflectionMarshalAsAttributeHandle
+ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method, MonoError *error)
{
- MonoError error;
+ mono_error_init (error);
MonoDomain *domain = mono_domain_get ();
- MonoReflectionMarshalAsAttribute* res = NULL;
- MonoMarshalSpec **mspecs;
- int i;
+ MonoReflectionMarshalAsAttributeHandle res = MONO_HANDLE_NEW (MonoReflectionMarshalAsAttribute, NULL);
- mspecs = g_new (MonoMarshalSpec*, mono_method_signature (method)->param_count + 1);
+ MonoMarshalSpec **mspecs = g_new (MonoMarshalSpec*, mono_method_signature (method)->param_count + 1);
mono_method_get_marshal_info (method, mspecs);
if (mspecs [0]) {
- res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [0], &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return NULL;
- }
+ MONO_HANDLE_ASSIGN (res, mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [0], error));
+ if (!is_ok (error))
+ goto leave;
}
- for (i = mono_method_signature (method)->param_count; i >= 0; i--)
+leave:
+ for (int i = mono_method_signature (method)->param_count; i >= 0; i--)
if (mspecs [i])
mono_metadata_free_marshal_spec (mspecs [i]);
g_free (mspecs);
return res;
}
-ICALL_EXPORT MonoReflectionMethodBody*
-ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod *method)
+ICALL_EXPORT MonoReflectionMethodBodyHandle
+ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod *method, MonoError *error)
{
- MonoError error;
- MonoReflectionMethodBody *result = mono_method_body_get_object_checked (mono_domain_get (), method, &error);
- mono_error_set_pending_exception (&error);
- return result;
+ mono_error_init (error);
+ return mono_method_body_get_object_handle (mono_domain_get (), method, error);
}
ICALL_EXPORT MonoReflectionAssemblyHandle
}
}
+static MonoGenericInst *
+get_generic_inst_from_array_handle (MonoArrayHandle type_args)
+{
+ int type_argc = mono_array_handle_length (type_args);
+ int size = MONO_SIZEOF_GENERIC_INST + type_argc * sizeof (MonoType *);
+
+ MonoGenericInst *ginst = (MonoGenericInst *)g_alloca (size);
+ memset (ginst, 0, sizeof (MonoGenericInst));
+ ginst->type_argc = type_argc;
+ for (int i = 0; i < type_argc; i++) {
+ MONO_HANDLE_ARRAY_GETVAL (ginst->type_argv[i], type_args, MonoType*, i);
+ }
+ ginst->is_open = FALSE;
+ for (int i = 0; i < type_argc; i++) {
+ if (mono_class_is_open_constructed_type (ginst->type_argv[i])) {
+ ginst->is_open = TRUE;
+ break;
+ }
+ }
+
+ return mono_metadata_get_canonical_generic_inst (ginst);
+}
+
static void
-init_generic_context_from_args (MonoGenericContext *context, MonoArray *type_args, MonoArray *method_args)
+init_generic_context_from_args_handles (MonoGenericContext *context, MonoArrayHandle type_args, MonoArrayHandle method_args)
{
- if (type_args)
- context->class_inst = mono_metadata_get_generic_inst (mono_array_length (type_args),
- mono_array_addr (type_args, MonoType*, 0));
- else
+ if (!MONO_HANDLE_IS_NULL (type_args)) {
+ context->class_inst = get_generic_inst_from_array_handle (type_args);
+ } else {
context->class_inst = NULL;
- if (method_args)
- context->method_inst = mono_metadata_get_generic_inst (mono_array_length (method_args),
- mono_array_addr (method_args, MonoType*, 0));
- else
+ }
+ if (!MONO_HANDLE_IS_NULL (method_args)) {
+ context->method_inst = get_generic_inst_from_array_handle (method_args);
+ } else {
context->method_inst = NULL;
+ }
}
-ICALL_EXPORT MonoType*
-ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *resolve_error)
+
+static MonoType*
+module_resolve_type_token (MonoImage *image, guint32 token, MonoArrayHandle type_args, MonoArrayHandle method_args, MonoResolveTokenError *resolve_error, MonoError *error)
{
+ HANDLE_FUNCTION_ENTER ();
+ mono_error_init (error);
+ MonoType *result = NULL;
MonoClass *klass;
int table = mono_metadata_token_table (token);
int index = mono_metadata_token_index (token);
MonoGenericContext context;
- MonoError error;
*resolve_error = ResolveTokenError_Other;
if ((table != MONO_TABLE_TYPEDEF) && (table != MONO_TABLE_TYPEREF) &&
(table != MONO_TABLE_TYPESPEC)) {
*resolve_error = ResolveTokenError_BadTable;
- return NULL;
+ goto leave;
}
if (image_is_dynamic (image)) {
if ((table == MONO_TABLE_TYPEDEF) || (table == MONO_TABLE_TYPEREF)) {
- klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &error);
- mono_error_cleanup (&error);
- return klass ? &klass->byval_arg : NULL;
+ MonoError inner_error;
+ klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &inner_error);
+ mono_error_cleanup (&inner_error);
+ result = klass ? &klass->byval_arg : NULL;
+ goto leave;
}
- init_generic_context_from_args (&context, type_args, method_args);
- klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &error);
- mono_error_cleanup (&error);
- return klass ? &klass->byval_arg : NULL;
+ init_generic_context_from_args_handles (&context, type_args, method_args);
+ MonoError inner_error;
+ klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &inner_error);
+ mono_error_cleanup (&inner_error);
+ result = klass ? &klass->byval_arg : NULL;
+ goto leave;
}
if ((index <= 0) || (index > image->tables [table].rows)) {
*resolve_error = ResolveTokenError_OutOfRange;
- return NULL;
+ goto leave;
}
- init_generic_context_from_args (&context, type_args, method_args);
- klass = mono_class_get_checked (image, token, &error);
+ init_generic_context_from_args_handles (&context, type_args, method_args);
+ klass = mono_class_get_checked (image, token, error);
if (klass)
- klass = mono_class_inflate_generic_class_checked (klass, &context, &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return NULL;
- }
+ klass = mono_class_inflate_generic_class_checked (klass, &context, error);
+ if (!is_ok (error))
+ goto leave;
if (klass)
- return &klass->byval_arg;
- else
- return NULL;
+ result = &klass->byval_arg;
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (result);
+
+}
+ICALL_EXPORT MonoType*
+ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage *image, guint32 token, MonoArrayHandle type_args, MonoArrayHandle method_args, MonoResolveTokenError *resolve_error, MonoError *error)
+{
+ return module_resolve_type_token (image, token, type_args, method_args, resolve_error, error);
}
-ICALL_EXPORT MonoMethod*
-ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *resolve_error)
+static MonoMethod*
+module_resolve_method_token (MonoImage *image, guint32 token, MonoArrayHandle type_args, MonoArrayHandle method_args, MonoResolveTokenError *resolve_error, MonoError *error)
{
- MonoError error;
+ HANDLE_FUNCTION_ENTER ();
+ mono_error_init (error);
+ MonoMethod *method = NULL;
int table = mono_metadata_token_table (token);
int index = mono_metadata_token_index (token);
MonoGenericContext context;
- MonoMethod *method;
*resolve_error = ResolveTokenError_Other;
if ((table != MONO_TABLE_METHOD) && (table != MONO_TABLE_METHODSPEC) &&
(table != MONO_TABLE_MEMBERREF)) {
*resolve_error = ResolveTokenError_BadTable;
- return NULL;
+ goto leave;
}
if (image_is_dynamic (image)) {
if (table == MONO_TABLE_METHOD) {
- method = (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &error);
- mono_error_cleanup (&error);
- return method;
+ MonoError inner_error;
+ method = (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &inner_error);
+ mono_error_cleanup (&inner_error);
+ goto leave;
}
if ((table == MONO_TABLE_MEMBERREF) && !(mono_memberref_is_method (image, token))) {
*resolve_error = ResolveTokenError_BadTable;
- return NULL;
+ goto leave;
}
- init_generic_context_from_args (&context, type_args, method_args);
- method = (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &error);
- mono_error_cleanup (&error);
- return method;
+ init_generic_context_from_args_handles (&context, type_args, method_args);
+ MonoError inner_error;
+ method = (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &inner_error);
+ mono_error_cleanup (&inner_error);
+ goto leave;
}
if ((index <= 0) || (index > image->tables [table].rows)) {
*resolve_error = ResolveTokenError_OutOfRange;
- return NULL;
+ goto leave;
}
if ((table == MONO_TABLE_MEMBERREF) && (!mono_memberref_is_method (image, token))) {
*resolve_error = ResolveTokenError_BadTable;
- return NULL;
+ goto leave;
}
- init_generic_context_from_args (&context, type_args, method_args);
- method = mono_get_method_checked (image, token, NULL, &context, &error);
- mono_error_set_pending_exception (&error);
+ init_generic_context_from_args_handles (&context, type_args, method_args);
+ method = mono_get_method_checked (image, token, NULL, &context, error);
- return method;
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (method);
+}
+
+ICALL_EXPORT MonoMethod*
+ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoArrayHandle type_args, MonoArrayHandle method_args, MonoResolveTokenError *resolve_error, MonoError *error)
+{
+ return module_resolve_method_token (image, token, type_args, method_args, resolve_error, error);
}
ICALL_EXPORT MonoString*
return result;
}
-ICALL_EXPORT MonoClassField*
-ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *resolve_error)
+static MonoClassField*
+module_resolve_field_token (MonoImage *image, guint32 token, MonoArrayHandle type_args, MonoArrayHandle method_args, MonoResolveTokenError *resolve_error, MonoError *error)
{
- MonoError error;
+ HANDLE_FUNCTION_ENTER ();
MonoClass *klass;
int table = mono_metadata_token_table (token);
int index = mono_metadata_token_index (token);
MonoGenericContext context;
- MonoClassField *field;
+ MonoClassField *field = NULL;
+ mono_error_init (error);
*resolve_error = ResolveTokenError_Other;
/* Validate token */
if ((table != MONO_TABLE_FIELD) && (table != MONO_TABLE_MEMBERREF)) {
*resolve_error = ResolveTokenError_BadTable;
- return NULL;
+ goto leave;
}
if (image_is_dynamic (image)) {
if (table == MONO_TABLE_FIELD) {
- field = (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &error);
- mono_error_cleanup (&error);
- return field;
+ MonoError inner_error;
+ field = (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &inner_error);
+ mono_error_cleanup (&inner_error);
+ goto leave;
}
if (mono_memberref_is_method (image, token)) {
*resolve_error = ResolveTokenError_BadTable;
- return NULL;
+ goto leave;
}
- init_generic_context_from_args (&context, type_args, method_args);
- field = (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &error);
- mono_error_cleanup (&error);
- return field;
+ init_generic_context_from_args_handles (&context, type_args, method_args);
+ MonoError inner_error;
+ field = (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &inner_error);
+ mono_error_cleanup (&inner_error);
+ goto leave;
}
if ((index <= 0) || (index > image->tables [table].rows)) {
*resolve_error = ResolveTokenError_OutOfRange;
- return NULL;
+ goto leave;
}
if ((table == MONO_TABLE_MEMBERREF) && (mono_memberref_is_method (image, token))) {
*resolve_error = ResolveTokenError_BadTable;
- return NULL;
+ goto leave;
}
- init_generic_context_from_args (&context, type_args, method_args);
- field = mono_field_from_token_checked (image, token, &klass, &context, &error);
- mono_error_set_pending_exception (&error);
+ init_generic_context_from_args_handles (&context, type_args, method_args);
+ field = mono_field_from_token_checked (image, token, &klass, &context, error);
- return field;
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (field);
}
+ICALL_EXPORT MonoClassField*
+ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage *image, guint32 token, MonoArrayHandle type_args, MonoArrayHandle method_args, MonoResolveTokenError *resolve_error, MonoError *error)
+{
+ return module_resolve_field_token (image, token, type_args, method_args, resolve_error, error);
+}
-ICALL_EXPORT MonoObject*
-ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
+ICALL_EXPORT MonoObjectHandle
+ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoArrayHandle type_args, MonoArrayHandle method_args, MonoResolveTokenError *error, MonoError *merror)
{
- MonoError merror;
- MonoObject *ret;
int table = mono_metadata_token_table (token);
+ mono_error_init (merror);
*error = ResolveTokenError_Other;
switch (table) {
case MONO_TABLE_TYPEDEF:
case MONO_TABLE_TYPEREF:
case MONO_TABLE_TYPESPEC: {
- MonoType *t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
+ MonoType *t = module_resolve_type_token (image, token, type_args, method_args, error, merror);
if (t) {
- ret = (MonoObject*) mono_type_get_object_checked (mono_domain_get (), t, &merror);
- mono_error_set_pending_exception (&merror);
-
- return ret;
+ return MONO_HANDLE_CAST (MonoObject, mono_type_get_object_handle (mono_domain_get (), t, merror));
}
else
- return NULL;
+ return NULL_HANDLE;
}
case MONO_TABLE_METHOD:
case MONO_TABLE_METHODSPEC: {
- MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
+ MonoMethod *m = module_resolve_method_token (image, token, type_args, method_args, error, merror);
if (m) {
- ret = (MonoObject*)mono_method_get_object_checked (mono_domain_get (), m, m->klass, &merror);
- mono_error_set_pending_exception (&merror);
-
- return ret;
+ return MONO_HANDLE_CAST (MonoObject, mono_method_get_object_handle (mono_domain_get (), m, m->klass, merror));
} else
- return NULL;
+ return NULL_HANDLE;
}
case MONO_TABLE_FIELD: {
- MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
+ MonoClassField *f = module_resolve_field_token (image, token, type_args, method_args, error, merror);
if (f) {
- ret =(MonoObject*)mono_field_get_object_checked (mono_domain_get (), f->parent, f, &merror);
- mono_error_set_pending_exception (&merror);
- return ret;
+ return MONO_HANDLE_CAST (MonoObject, mono_field_get_object_handle (mono_domain_get (), f->parent, f, merror));
}
else
- return NULL;
+ return NULL_HANDLE;
}
case MONO_TABLE_MEMBERREF:
if (mono_memberref_is_method (image, token)) {
- MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
+ MonoMethod *m = module_resolve_method_token (image, token, type_args, method_args, error, merror);
if (m) {
- ret = (MonoObject*)mono_method_get_object_checked (mono_domain_get (), m, m->klass, &merror);
- mono_error_set_pending_exception (&merror);
-
- return ret;
+ return MONO_HANDLE_CAST (MonoObject, mono_method_get_object_handle (mono_domain_get (), m, m->klass, merror));
} else
- return NULL;
+ return NULL_HANDLE;
}
else {
- MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
+ MonoClassField *f = module_resolve_field_token (image, token, type_args, method_args, error, merror);
if (f) {
- ret = (MonoObject*)mono_field_get_object_checked (mono_domain_get (), f->parent, f, &merror);
- mono_error_set_pending_exception (&merror);
- return ret;
+ return MONO_HANDLE_CAST (MonoObject, mono_field_get_object_handle (mono_domain_get (), f->parent, f, merror));
}
else
- return NULL;
+ return NULL_HANDLE;
}
break;
*error = ResolveTokenError_BadTable;
}
- return NULL;
+ return NULL_HANDLE;
}
ICALL_EXPORT MonoArray*
*decHexDigits = Formatter_DecHexDigits;
}
+static gboolean
+add_modifier_to_array (MonoDomain *domain, MonoImage *image, MonoCustomMod *modifier, MonoArrayHandle dest, int dest_idx, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER ();
+ mono_error_init (error);
+ MonoClass *klass = mono_class_get_checked (image, modifier->token, error);
+ if (!is_ok (error))
+ goto leave;
+
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &klass->byval_arg, error);
+ if (!is_ok (error))
+ goto leave;
+
+ MONO_HANDLE_ARRAY_SETREF (dest, dest_idx, rt);
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
+}
+
/*
* We return NULL for no modifiers so the corlib code can return Type.EmptyTypes
* and avoid useless allocations.
*/
-static MonoArray*
+static MonoArrayHandle
type_array_from_modifiers (MonoImage *image, MonoType *type, int optional, MonoError *error)
{
- MonoReflectionType *rt;
- MonoArray *res;
int i, count = 0;
+ MonoDomain *domain = mono_domain_get ();
mono_error_init (error);
for (i = 0; i < type->num_mods; ++i) {
count++;
}
if (!count)
- return NULL;
- res = mono_array_new_checked (mono_domain_get (), mono_defaults.systemtype_class, count, error);
- return_val_if_nok (error, NULL);
+ return MONO_HANDLE_NEW (MonoArray, NULL);
+
+ MonoArrayHandle res = mono_array_new_handle (domain, mono_defaults.systemtype_class, count, error);
+ if (!is_ok (error))
+ goto fail;
count = 0;
for (i = 0; i < type->num_mods; ++i) {
if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required)) {
- MonoClass *klass = mono_class_get_checked (image, type->modifiers [i].token, error);
- return_val_if_nok (error, NULL);
-
- rt = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, error);
- return_val_if_nok (error, NULL);
-
- mono_array_setref (res, count, rt);
+ if (!add_modifier_to_array (domain, image, &type->modifiers[i], res, count , error))
+ goto fail;
count++;
}
}
return res;
+fail:
+ return MONO_HANDLE_NEW (MonoArray, NULL);
}
-ICALL_EXPORT MonoArray*
-ves_icall_ParameterInfo_GetTypeModifiers (MonoReflectionParameter *param, MonoBoolean optional)
+ICALL_EXPORT MonoArrayHandle
+ves_icall_ParameterInfo_GetTypeModifiers (MonoReflectionParameterHandle param, MonoBoolean optional, MonoError *error)
{
- MonoError error;
- MonoType *type = param->ClassImpl->type;
- MonoClass *member_class = mono_object_class (param->MemberImpl);
+ mono_error_init (error);
+ MonoReflectionTypeHandle rt = MONO_HANDLE_NEW (MonoReflectionType, NULL);
+ MONO_HANDLE_GET (rt, param, ClassImpl);
+ MonoType *type = MONO_HANDLE_GETVAL (rt, type);
+ MonoObjectHandle member = MONO_HANDLE_NEW (MonoObject, NULL);
+ MONO_HANDLE_GET (member, param, MemberImpl);
+ MonoClass *member_class = mono_handle_class (member);
MonoMethod *method = NULL;
MonoImage *image;
int pos;
MonoMethodSignature *sig;
- MonoArray *res;
if (mono_class_is_reflection_method_or_constructor (member_class)) {
- MonoReflectionMethod *rmethod = (MonoReflectionMethod*)param->MemberImpl;
- method = rmethod->method;
+ method = MONO_HANDLE_GETVAL (MONO_HANDLE_CAST (MonoReflectionMethod, member), method);
} else if (member_class->image == mono_defaults.corlib && !strcmp ("MonoProperty", member_class->name)) {
- MonoReflectionProperty *prop = (MonoReflectionProperty *)param->MemberImpl;
- if (!(method = prop->property->get))
- method = prop->property->set;
+ MonoProperty *prop = MONO_HANDLE_GETVAL (MONO_HANDLE_CAST (MonoReflectionProperty, member), property);
+ if (!(method = prop->get))
+ method = prop->set;
g_assert (method);
} else {
char *type_name = mono_type_get_full_name (member_class);
- char *msg = g_strdup_printf ("Custom modifiers on a ParamInfo with member %s are not supported", type_name);
- MonoException *ex = mono_get_exception_not_supported (msg);
+ mono_error_set_not_supported (error, "Custom modifiers on a ParamInfo with member %s are not supported", type_name);
g_free (type_name);
- g_free (msg);
- mono_set_pending_exception (ex);
- return NULL;
+ return MONO_HANDLE_CAST (MonoArray, NULL_HANDLE);
}
image = method->klass->image;
- pos = param->PositionImpl;
+ pos = MONO_HANDLE_GETVAL (param, PositionImpl);
sig = mono_method_signature (method);
if (pos == -1)
type = sig->ret;
else
type = sig->params [pos];
- res = type_array_from_modifiers (image, type, optional, &error);
- mono_error_set_pending_exception (&error);
- return res;
+ return type_array_from_modifiers (image, type, optional, error);
}
static MonoType*
return NULL;
}
-ICALL_EXPORT MonoArray*
-ves_icall_MonoPropertyInfo_GetTypeModifiers (MonoReflectionProperty *property, MonoBoolean optional)
+ICALL_EXPORT MonoArrayHandle
+ves_icall_MonoPropertyInfo_GetTypeModifiers (MonoReflectionPropertyHandle property, MonoBoolean optional, MonoError *error)
{
- MonoError error;
- MonoType *type = get_property_type (property->property);
- MonoImage *image = property->klass->image;
- MonoArray *res;
+ mono_error_init (error);
+ MonoProperty *prop = MONO_HANDLE_GETVAL (property, property);
+ MonoClass *klass = MONO_HANDLE_GETVAL (property, klass);
+ MonoType *type = get_property_type (prop);
+ MonoImage *image = klass->image;
if (!type)
- return NULL;
- res = type_array_from_modifiers (image, type, optional, &error);
- mono_error_set_pending_exception (&error);
- return res;
+ return MONO_HANDLE_CAST (MonoArray, NULL_HANDLE);
+ return type_array_from_modifiers (image, type, optional, error);
}
/*
mono_metadata_get_generic_inst (int type_argc,
MonoType **type_argv);
+MonoGenericInst *
+mono_metadata_get_canonical_generic_inst (MonoGenericInst *candidate);
+
MonoGenericClass *
mono_metadata_lookup_generic_class (MonoClass *gclass,
MonoGenericInst *inst,
gboolean is_open;
int i;
int size = MONO_SIZEOF_GENERIC_INST + type_argc * sizeof (MonoType *);
- CollectData data;
- MonoImageSet *set;
for (i = 0; i < type_argc; ++i)
if (mono_class_is_open_constructed_type (type_argv [i]))
ginst->type_argc = type_argc;
memcpy (ginst->type_argv, type_argv, type_argc * sizeof (MonoType *));
+ return mono_metadata_get_canonical_generic_inst (ginst);
+}
+
+
+/**
+ * mono_metadata_get_canonical_generic_inst:
+ * @candidate: an arbitrary generic instantiation
+ *
+ * Returns the canonical generic instantiation that represents the given
+ * candidate by identifying the image set for the candidate instantiation and
+ * finding the instance in the image set or adding a copy of the given instance
+ * to the image set.
+ *
+ * The returned MonoGenericInst has its own copy of the list of types. The list
+ * passed in the argument can be freed, modified or disposed of.
+ *
+ */
+MonoGenericInst *
+mono_metadata_get_canonical_generic_inst (MonoGenericInst *candidate)
+{
+ CollectData data;
+ int type_argc = candidate->type_argc;
+ gboolean is_open = candidate->is_open;
+ MonoImageSet *set;
+
collect_data_init (&data);
- collect_ginst_images (ginst, &data);
+ collect_ginst_images (candidate, &data);
set = get_image_set (data.images, data.nimages);
mono_image_set_lock (set);
- ginst = (MonoGenericInst *)g_hash_table_lookup (set->ginst_cache, ginst);
+ MonoGenericInst *ginst = (MonoGenericInst *)g_hash_table_lookup (set->ginst_cache, candidate);
if (!ginst) {
+ int size = MONO_SIZEOF_GENERIC_INST + type_argc * sizeof (MonoType *);
ginst = (MonoGenericInst *)mono_image_set_alloc0 (set, size);
#ifndef MONO_SMALL_CONFIG
ginst->id = ++next_generic_inst_id;
ginst->is_open = is_open;
ginst->type_argc = type_argc;
- for (i = 0; i < type_argc; ++i)
- ginst->type_argv [i] = mono_metadata_type_dup (NULL, type_argv [i]);
+ for (int i = 0; i < type_argc; ++i)
+ ginst->type_argv [i] = mono_metadata_type_dup (NULL, candidate->type_argv [i]);
g_hash_table_insert (set->ginst_cache, ginst, ginst);
}
/* Safely access System.Reflection.MonoMethod from native code */
TYPED_HANDLE_DECL (MonoReflectionMethod);
-typedef struct _MonoReflectionGenericMethod MonoReflectionGenericMethod;
-struct _MonoReflectionGenericMethod {
- MonoReflectionMethod method;
-};
-
struct _MonoDelegate {
MonoObject object;
/* The compiled code of the target method */
guint32 attrs;
};
+/* Safely access System.Reflection.MonoField from native code */
+TYPED_HANDLE_DECL (MonoReflectionField);
+
struct _MonoReflectionProperty {
MonoObject object;
MonoClass *klass;
MonoProperty *property;
};
+/* Safely access System.Reflection.MonoProperty from native code */
+TYPED_HANDLE_DECL (MonoReflectionProperty);
+
/*This is System.EventInfo*/
struct _MonoReflectionEvent {
MonoObject object;
MonoObject *cached_add_event;
};
+/* Safely access System.Reflection.EventInfo from native code */
+TYPED_HANDLE_DECL (MonoReflectionEvent);
+
typedef struct {
MonoReflectionEvent object;
MonoClass *klass;
MonoEvent *event;
} MonoReflectionMonoEvent;
+/* Safely access Systme.Reflection.MonoEvent from native code */
+TYPED_HANDLE_DECL (MonoReflectionMonoEvent);
+
typedef struct {
MonoObject object;
MonoReflectionType *ClassImpl;
MonoObject *MarshalAsImpl;
} MonoReflectionParameter;
+/* Safely access System.Reflection.ParameterInfo from native code */
+TYPED_HANDLE_DECL (MonoReflectionParameter);
+
struct _MonoReflectionMethodBody {
MonoObject object;
MonoArray *clauses;
guint32 max_stack;
};
+/* Safely access System.Reflection.MethodBody from native code */
+TYPED_HANDLE_DECL (MonoReflectionMethodBody);
+
struct _MonoReflectionAssembly {
MonoObject object;
MonoAssembly *assembly;
gint32 handler_length;
} MonoReflectionExceptionHandlingClause;
+
+/* Safely access System.Reflection.ExceptionHandlingClause from native code */
+TYPED_HANDLE_DECL (MonoReflectionExceptionHandlingClause);
+
typedef struct {
MonoObject object;
MonoReflectionType *local_type;
guint16 local_index;
} MonoReflectionLocalVariableInfo;
+/* Safely access System.Reflection.LocalVariableInfo from native code */
+TYPED_HANDLE_DECL (MonoReflectionLocalVariableInfo);
+
typedef struct {
/*
* Must have the same layout as MonoReflectionLocalVariableInfo, since
gint16 size_param_index;
} MonoReflectionMarshalAsAttribute;
+/* Safely access System.Runtime.InteropServices.MarshalAsAttribute */
+TYPED_HANDLE_DECL (MonoReflectionMarshalAsAttribute);
+
typedef struct {
MonoObject object;
gint32 call_conv;
void mono_reflection_create_custom_attr_data_args (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len, MonoArray **typed_args, MonoArray **named_args, CattrNamedArg **named_arg_info, MonoError *error);
MonoMethodSignature * mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token, MonoError *error);
-MonoArray* mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error);
+MonoArrayHandle mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error);
MonoClass*
mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic);
MonoArray *
ves_icall_SignatureHelper_get_signature_field (MonoReflectionSigHelper *sig);
-MonoReflectionMarshalAsAttribute* mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec, MonoError *error);
+MonoReflectionMarshalAsAttributeHandle
+mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec, MonoError *error);
gpointer
mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context, MonoError *error);
return obj;
}
-
#define CACHE_OBJECT(t,p,o,k) ((t) (cache_object (domain, (k), (p), (o))))
-
-static inline MonoObject*
-check_object (MonoDomain* domain, MonoClass *klass, gpointer item)
-{
- ReflectedEntry e;
- e.item = item;
- e.refclass = klass;
- mono_domain_lock (domain);
- if (!domain->refobject_hash)
- domain->refobject_hash = mono_g_hash_table_new_type (reflected_hash, reflected_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection objects table");
- MonoObject *obj = (MonoObject*) mono_g_hash_table_lookup (domain->refobject_hash, &e);
- mono_domain_unlock (domain);
- return obj;
-}
-
static inline MonoObjectHandle
check_object_handle (MonoDomain* domain, MonoClass *klass, gpointer item)
{
}
-typedef MonoObject* (*ReflectionCacheConstructFunc) (MonoDomain*, MonoClass*, gpointer, gpointer, MonoError *);
-
typedef MonoObjectHandle (*ReflectionCacheConstructFunc_handle) (MonoDomain*, MonoClass*, gpointer, gpointer, MonoError *);
-
-static inline MonoObject*
-check_or_construct (MonoDomain *domain, MonoClass *klass, gpointer item, gpointer user_data, MonoError *error, ReflectionCacheConstructFunc construct)
-{
- mono_error_init (error);
- MonoObject *obj = check_object (domain, klass, item);
- if (obj)
- return obj;
- obj = construct (domain, klass, item, user_data, error);
- return_val_if_nok (error, NULL);
- /* note no caching if there was an error in construction */
- return cache_object (domain, klass, item, obj);
-}
-
static inline MonoObjectHandle
check_or_construct_handle (MonoDomain *domain, MonoClass *klass, gpointer item, gpointer user_data, MonoError *error, ReflectionCacheConstructFunc_handle construct)
{
}
-#define CHECK_OR_CONSTRUCT(t,p,k,construct,ud) ((t) check_or_construct (domain, (k), (p), (ud), error, (ReflectionCacheConstructFunc) (construct)))
-
#define CHECK_OR_CONSTRUCT_HANDLE(t,p,k,construct,ud) ((t) check_or_construct_handle (domain, (k), (p), (ud), error, (ReflectionCacheConstructFunc_handle) (construct)))
MonoReflectionField*
mono_field_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoClassField *field, MonoError *error);
+MonoReflectionFieldHandle
+mono_field_get_object_handle (MonoDomain *domain, MonoClass *klass, MonoClassField *field, MonoError *error);
+
MonoReflectionMethod*
mono_method_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error);
MonoReflectionProperty*
mono_property_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoProperty *property, MonoError *error);
-MonoReflectionEvent*
-mono_event_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoEvent *event, MonoError *error);
+MonoReflectionPropertyHandle
+mono_property_get_object_handle (MonoDomain *domain, MonoClass *klass, MonoProperty *property, MonoError *error);
+
+MonoReflectionEventHandle
+mono_event_get_object_handle (MonoDomain *domain, MonoClass *klass, MonoEvent *event, MonoError *error);
MonoReflectionModuleHandle
mono_module_get_object_handle (MonoDomain *domain, MonoImage *image, MonoError *error);
MonoReflectionModuleHandle
mono_module_file_get_object_handle (MonoDomain *domain, MonoImage *image, int table_index, MonoError *error);
-MonoReflectionMethodBody*
-mono_method_body_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoError *error);
+MonoReflectionMethodBodyHandle
+mono_method_body_get_object_handle (MonoDomain *domain, MonoMethod *method, MonoError *error);
MonoClass *
mono_class_from_mono_type_handle (MonoReflectionTypeHandle h);
klass = mono_class_get_mono_method_class ();
}
MonoReflectionMethodHandle ret = MONO_HANDLE_NEW (MonoReflectionMethod, mono_object_new_checked (domain, klass, error));
- if (!mono_error_ok (error))
- goto leave;
+ if (!is_ok (error))
+ goto fail;
MONO_HANDLE_SETVAL (ret, method, MonoMethod*, method);
MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &refclass->byval_arg, error);
- if (!mono_error_ok (error))
- goto leave;
+ if (!is_ok (error))
+ goto fail;
MONO_HANDLE_SET (ret, reftype, rt);
-leave:
return ret;
+
+fail:
+ return MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE);
}
/*
mono_method_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
MonoReflectionMethodHandle result = mono_method_get_object_handle (domain, method, refclass, error);
HANDLE_FUNCTION_RETURN_OBJ (result);
}
MonoReflectionField*
mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *field)
{
+ HANDLE_FUNCTION_ENTER ();
MonoError error;
- MonoReflectionField *result;
- result = mono_field_get_object_checked (domain, klass, field, &error);
+ MonoReflectionFieldHandle result = mono_field_get_object_handle (domain, klass, field, &error);
mono_error_cleanup (&error);
- return result;
+ HANDLE_FUNCTION_RETURN_OBJ (result);
}
-static MonoReflectionField*
+static MonoReflectionFieldHandle
field_object_construct (MonoDomain *domain, MonoClass *klass, MonoClassField *field, gpointer user_data, MonoError *error)
{
- MonoReflectionType *rt;
- MonoReflectionField *res;
-
mono_error_init (error);
- res = (MonoReflectionField *)mono_object_new_checked (domain, mono_class_get_mono_field_class (), error);
- if (!res)
- return NULL;
- res->klass = klass;
- res->field = field;
- MONO_OBJECT_SETREF (res, name, mono_string_new (domain, mono_field_get_name (field)));
+ MonoReflectionFieldHandle res = MONO_HANDLE_NEW (MonoReflectionField, mono_object_new_checked (domain, mono_class_get_mono_field_class (), error));
+ if (!is_ok (error))
+ goto fail;
+ MONO_HANDLE_SETVAL (res, klass, MonoClass *, klass);
+ MONO_HANDLE_SETVAL (res, field, MonoClassField *, field);
+ MonoStringHandle name = mono_string_new_handle (domain, mono_field_get_name (field), error);
+ if (!is_ok (error))
+ goto fail;
+ MONO_HANDLE_SET (res, name, name);
if (field->type) {
- rt = mono_type_get_object_checked (domain, field->type, error);
- if (!mono_error_ok (error))
- return NULL;
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, field->type, error);
+ if (!is_ok (error))
+ goto fail;
- MONO_OBJECT_SETREF (res, type, rt);
+ MONO_HANDLE_SET (res, type, rt);
}
- res->attrs = mono_field_get_flags (field);
+ MONO_HANDLE_SETVAL (res, attrs, guint32, mono_field_get_flags (field));
return res;
+fail:
+ return MONO_HANDLE_CAST (MonoReflectionField, NULL_HANDLE);
}
+/*
+ * mono_field_get_object_handle:
+ * @domain: an app domain
+ * @klass: a type
+ * @field: a field
+ * @error: set on error
+ *
+ * Return an System.Reflection.MonoField object representing the field @field
+ * in class @klass. On error, returns NULL and sets @error.
+ */
+MonoReflectionFieldHandle
+mono_field_get_object_handle (MonoDomain *domain, MonoClass *klass, MonoClassField *field, MonoError *error)
+{
+ mono_error_init (error);
+ return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionFieldHandle, field, klass, field_object_construct, NULL);
+}
+
+
/*
* mono_field_get_object_checked:
* @domain: an app domain
MonoReflectionField*
mono_field_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoClassField *field, MonoError *error)
{
- mono_error_init (error);
- return CHECK_OR_CONSTRUCT (MonoReflectionField*, field, klass, field_object_construct, NULL);
+ HANDLE_FUNCTION_ENTER ();
+ MonoReflectionFieldHandle result = mono_field_get_object_handle (domain, klass, field, error);
+ HANDLE_FUNCTION_RETURN_OBJ (result);
}
/*
MonoReflectionProperty*
mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property)
{
+ HANDLE_FUNCTION_ENTER ();
MonoError error;
- MonoReflectionProperty *result;
- result = mono_property_get_object_checked (domain, klass, property, &error);
+ MonoReflectionPropertyHandle result = mono_property_get_object_handle (domain, klass, property, &error);
mono_error_cleanup (&error);
- return result;
+ HANDLE_FUNCTION_RETURN_OBJ (result);
}
-static MonoReflectionProperty*
+static MonoReflectionPropertyHandle
property_object_construct (MonoDomain *domain, MonoClass *klass, MonoProperty *property, gpointer user_data, MonoError *error)
{
- MonoReflectionProperty *res;
-
mono_error_init (error);
- res = (MonoReflectionProperty *)mono_object_new_checked (domain, mono_class_get_mono_property_class (), error);
- if (!res)
- return NULL;
- res->klass = klass;
- res->property = property;
+ MonoReflectionPropertyHandle res = MONO_HANDLE_NEW (MonoReflectionProperty, mono_object_new_checked (domain, mono_class_get_mono_property_class (), error));
+ if (!is_ok (error))
+ goto fail;
+ MONO_HANDLE_SETVAL (res, klass, MonoClass *, klass);
+ MONO_HANDLE_SETVAL (res, property, MonoProperty *, property);
return res;
+fail:
+ return MONO_HANDLE_CAST (MonoReflectionProperty, NULL_HANDLE);
+}
+
+/**
+ * mono_property_get_object_handle:
+ * @domain: an app domain
+ * @klass: a type
+ * @property: a property
+ * @error: set on error
+ *
+ * Return an System.Reflection.MonoProperty object representing the property @property
+ * in class @klass. On error returns NULL and sets @error.
+ */
+MonoReflectionPropertyHandle
+mono_property_get_object_handle (MonoDomain *domain, MonoClass *klass, MonoProperty *property, MonoError *error)
+{
+ return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionPropertyHandle, property, klass, property_object_construct, NULL);
}
/**
MonoReflectionProperty*
mono_property_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoProperty *property, MonoError *error)
{
- mono_error_init (error);
- return CHECK_OR_CONSTRUCT (MonoReflectionProperty*, property, klass, property_object_construct, NULL);
+ HANDLE_FUNCTION_ENTER ();
+ MonoReflectionPropertyHandle res = mono_property_get_object_handle (domain, klass, property, error);
+ HANDLE_FUNCTION_RETURN_OBJ (res);
}
/*
MonoReflectionEvent*
mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event)
{
+ HANDLE_FUNCTION_ENTER ();
MonoError error;
- MonoReflectionEvent *result;
- result = mono_event_get_object_checked (domain, klass, event, &error);
+ MonoReflectionEventHandle result = mono_event_get_object_handle (domain, klass, event, &error);
mono_error_cleanup (&error);
- return result;
+ HANDLE_FUNCTION_RETURN_OBJ (result);
}
-static MonoReflectionEvent*
+static MonoReflectionEventHandle
event_object_construct (MonoDomain *domain, MonoClass *klass, MonoEvent *event, gpointer user_data, MonoError *error)
{
- MonoReflectionMonoEvent *mono_event;
mono_error_init (error);
- mono_event = (MonoReflectionMonoEvent *)mono_object_new_checked (domain, mono_class_get_mono_event_class (), error);
- if (!mono_event)
- return NULL;
- mono_event->klass = klass;
- mono_event->event = event;
- return &mono_event->object;
+ 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);
+ MONO_HANDLE_SETVAL (mono_event, klass, MonoClass* , klass);
+ MONO_HANDLE_SETVAL (mono_event, event, MonoEvent* , event);
+ return MONO_HANDLE_CAST (MonoReflectionEvent, mono_event);
}
/**
- * mono_event_get_object_checked:
+ * mono_event_get_object_handle:
* @domain: an app domain
* @klass: a type
* @event: a event
* Return an System.Reflection.MonoEvent object representing the event @event
* in class @klass. On failure sets @error and returns NULL
*/
-MonoReflectionEvent*
-mono_event_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoEvent *event, MonoError *error)
+MonoReflectionEventHandle
+mono_event_get_object_handle (MonoDomain *domain, MonoClass *klass, MonoEvent *event, MonoError *error)
{
mono_error_init (error);
- return CHECK_OR_CONSTRUCT (MonoReflectionEvent*, event, klass, event_object_construct, NULL);
+ return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionEventHandle, event, klass, event_object_construct, NULL);
}
+
/**
* mono_get_reflection_missing_object:
* @domain: Domain where the object lives
* Used as the value for ParameterInfo.DefaultValue when Optional
* is present
*/
-static MonoObject *
+static MonoObjectHandle
mono_get_reflection_missing_object (MonoDomain *domain)
{
MonoError error;
- MonoObject *obj;
static MonoClassField *missing_value_field = NULL;
if (!missing_value_field) {
missing_value_field = mono_class_get_field_from_name (missing_klass, "Value");
g_assert (missing_value_field);
}
- obj = mono_field_get_value_object_checked (domain, missing_value_field, NULL, &error);
+ /* FIXME change mono_field_get_value_object_checked to return a handle */
+ MonoObjectHandle obj = MONO_HANDLE_NEW (MonoObject, mono_field_get_value_object_checked (domain, missing_value_field, NULL, &error));
mono_error_assert_ok (&error);
return obj;
}
-static MonoObject*
+static MonoObjectHandle
get_dbnull_object (MonoDomain *domain, MonoError *error)
{
- MonoObject *obj;
static MonoClassField *dbnull_value_field = NULL;
mono_error_init (error);
dbnull_value_field = mono_class_get_field_from_name (dbnull_klass, "Value");
g_assert (dbnull_value_field);
}
- obj = mono_field_get_value_object_checked (domain, dbnull_value_field, NULL, error);
+ /* FIXME change mono_field_get_value_object_checked to return a handle */
+ MonoObjectHandle obj = MONO_HANDLE_NEW (MonoObject, mono_field_get_value_object_checked (domain, dbnull_value_field, NULL, error));
return obj;
}
-static MonoObject*
-get_dbnull (MonoDomain *domain, MonoObject **dbnull, MonoError *error)
+static MonoObjectHandle
+get_dbnull (MonoDomain *domain, MonoObjectHandle dbnull, MonoError *error)
{
mono_error_init (error);
- if (!*dbnull)
- *dbnull = get_dbnull_object (domain, error);
- return *dbnull;
+ if (MONO_HANDLE_IS_NULL (dbnull))
+ MONO_HANDLE_ASSIGN (dbnull, get_dbnull_object (domain, error));
+ return dbnull;
}
-static MonoObject*
-get_reflection_missing (MonoDomain *domain, MonoObject **reflection_missing)
+static MonoObjectHandle
+get_reflection_missing (MonoDomain *domain, MonoObjectHandleOut reflection_missing)
{
- if (!*reflection_missing)
- *reflection_missing = mono_get_reflection_missing_object (domain);
- return *reflection_missing;
+ if (MONO_HANDLE_IS_NULL (reflection_missing))
+ MONO_HANDLE_ASSIGN (reflection_missing, mono_get_reflection_missing_object (domain));
+ return reflection_missing;
}
-static MonoArray*
-param_objects_construct (MonoDomain *domain, MonoClass *refclass, MonoMethodSignature **addr_of_sig, gpointer user_data, MonoError *error)
+static gboolean
+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)
{
- static MonoClass *System_Reflection_ParameterInfo;
- static MonoClass *System_Reflection_ParameterInfo_array;
+ HANDLE_FUNCTION_ENTER ();
+ mono_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;
+
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, sig_param, error);
+ if (!is_ok (error))
+ goto leave;
+
+ MONO_HANDLE_SET (param, ClassImpl, rt);
+
+ MONO_HANDLE_SET (param, MemberImpl, member);
+
+ MonoStringHandle name_str = mono_string_new_handle (domain, name, error);
+ if (!is_ok (error))
+ goto leave;
+
+ MONO_HANDLE_SET (param, NameImpl, name_str);
+
+ MONO_HANDLE_SETVAL (param, PositionImpl, gint32, idx);
+
+ MONO_HANDLE_SETVAL (param, AttrsImpl, guint32, sig_param->attrs);
+
+ if (!(sig_param->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT)) {
+ if (sig_param->attrs & PARAM_ATTRIBUTE_OPTIONAL)
+ MONO_HANDLE_SET (param, DefaultValueImpl, get_reflection_missing (domain, missing));
+ else
+ MONO_HANDLE_SET (param, DefaultValueImpl, get_dbnull (domain, dbnull, error));
+ if (!is_ok (error))
+ goto leave;
+ } else {
+
+ MonoType blob_type;
+
+ blob_type.type = (MonoTypeEnum)blob_type_enum;
+ blob_type.data.klass = NULL;
+ if (blob_type_enum == MONO_TYPE_CLASS)
+ blob_type.data.klass = mono_defaults.object_class;
+ else if ((sig_param->type == MONO_TYPE_VALUETYPE) && sig_param->data.klass->enumtype) {
+ /* For enums, types [i] contains the base type */
+
+ blob_type.type = MONO_TYPE_VALUETYPE;
+ blob_type.data.klass = mono_class_from_mono_type (sig_param);
+ } else
+ blob_type.data.klass = mono_class_from_mono_type (&blob_type);
+
+ MonoObjectHandle default_val_obj = MONO_HANDLE_NEW (MonoObject, mono_get_object_from_blob (domain, &blob_type, blob, error)); /* FIXME make mono_get_object_from_blob return a handle */
+ if (!is_ok (error))
+ goto leave;
+ MONO_HANDLE_SET (param, DefaultValueImpl, default_val_obj);
+
+ /* Type in the Constant table is MONO_TYPE_CLASS for nulls */
+ if (blob_type_enum != MONO_TYPE_CLASS && MONO_HANDLE_IS_NULL(default_val_obj)) {
+ if (sig_param->attrs & PARAM_ATTRIBUTE_OPTIONAL)
+ MONO_HANDLE_SET (param, DefaultValueImpl, get_reflection_missing (domain, missing));
+ else
+ MONO_HANDLE_SET (param, DefaultValueImpl, get_dbnull (domain, dbnull, error));
+ if (!is_ok (error))
+ goto leave;
+ }
+ }
+ if (mspec) {
+ MonoReflectionMarshalAsAttributeHandle mobj = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspec, error);
+ if (!is_ok (error))
+ goto leave;
+ MONO_HANDLE_SET (param, MarshalAsImpl, mobj);
+ }
+
+ MONO_HANDLE_ARRAY_SETREF (dest, idx, param);
+
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
+}
+
+static MonoArrayHandle
+param_objects_construct (MonoDomain *domain, MonoClass *refclass, MonoMethodSignature **addr_of_sig, gpointer user_data, MonoError *error)
+{
MonoMethod *method = (MonoMethod*)user_data;
MonoMethodSignature *sig = *addr_of_sig; /* see note in mono_param_get_objects_internal */
- MonoArray *res = NULL;
- MonoReflectionMethod *member = NULL;
- MonoReflectionParameter *param = NULL;
+ MonoArrayHandle res = MONO_HANDLE_NEW (MonoArray, NULL);
char **names = NULL, **blobs = NULL;
guint32 *types = NULL;
- MonoType *type = NULL;
- MonoObject *dbnull = NULL;
- MonoObject *missing = NULL;
MonoMarshalSpec **mspecs = NULL;
- MonoVTable *pinfo_vtable;
- MonoReflectionType *rt;
int i;
mono_error_init (error);
- if (!System_Reflection_ParameterInfo_array) {
- MonoClass *klass;
- klass = mono_class_get_mono_parameter_info_class ();
- System_Reflection_ParameterInfo = klass;
- klass = mono_array_class_get (klass, 1);
- System_Reflection_ParameterInfo_array = klass;
- }
-
- member = mono_method_get_object_checked (domain, method, refclass, error);
- if (!member)
+ MonoReflectionMethodHandle member = mono_method_get_object_handle (domain, method, refclass, error);
+ if (!is_ok (error))
goto leave;
names = g_new (char *, sig->param_count);
mono_method_get_param_names (method, (const char **) names);
mspecs = g_new (MonoMarshalSpec*, sig->param_count + 1);
mono_method_get_marshal_info (method, mspecs);
- res = mono_array_new_specific_checked (mono_class_vtable (domain, System_Reflection_ParameterInfo_array), sig->param_count, error);
+ res = mono_array_new_handle (domain, mono_class_get_mono_parameter_info_class (), sig->param_count, error);
if (!res)
goto leave;
- pinfo_vtable = mono_class_vtable (domain, System_Reflection_ParameterInfo);
+ gboolean any_default_value = FALSE;
for (i = 0; i < sig->param_count; ++i) {
- param = (MonoReflectionParameter *) mono_object_new_specific_checked (pinfo_vtable, error);
- if (!param)
- goto leave;
-
- rt = mono_type_get_object_checked (domain, sig->params [i], error);
- if (!rt)
- goto leave;
-
- MONO_OBJECT_SETREF (param, ClassImpl, rt);
-
- MONO_OBJECT_SETREF (param, MemberImpl, (MonoObject*)member);
-
- MONO_OBJECT_SETREF (param, NameImpl, mono_string_new (domain, names [i]));
-
- param->PositionImpl = i;
- param->AttrsImpl = sig->params [i]->attrs;
-
- if (!(param->AttrsImpl & PARAM_ATTRIBUTE_HAS_DEFAULT)) {
- if (param->AttrsImpl & PARAM_ATTRIBUTE_OPTIONAL)
- MONO_OBJECT_SETREF (param, DefaultValueImpl, get_reflection_missing (domain, &missing));
- else
- MONO_OBJECT_SETREF (param, DefaultValueImpl, get_dbnull (domain, &dbnull, error));
- if (!is_ok (error))
- goto leave;
- } else {
-
- if (!blobs) {
- blobs = g_new0 (char *, sig->param_count);
- types = g_new0 (guint32, sig->param_count);
- get_default_param_value_blobs (method, blobs, types);
- }
-
- /* Build MonoType for the type from the Constant Table */
- if (!type)
- type = g_new0 (MonoType, 1);
- type->type = (MonoTypeEnum)types [i];
- type->data.klass = NULL;
- if (types [i] == MONO_TYPE_CLASS)
- type->data.klass = mono_defaults.object_class;
- else if ((sig->params [i]->type == MONO_TYPE_VALUETYPE) && sig->params [i]->data.klass->enumtype) {
- /* For enums, types [i] contains the base type */
-
- type->type = MONO_TYPE_VALUETYPE;
- type->data.klass = mono_class_from_mono_type (sig->params [i]);
- } else
- type->data.klass = mono_class_from_mono_type (type);
-
- MonoObject *default_val_obj = mono_get_object_from_blob (domain, type, blobs [i], error);
- if (!is_ok (error))
- goto leave;
- MONO_OBJECT_SETREF (param, DefaultValueImpl, default_val_obj);
-
- /* Type in the Constant table is MONO_TYPE_CLASS for nulls */
- if (types [i] != MONO_TYPE_CLASS && !param->DefaultValueImpl) {
- if (param->AttrsImpl & PARAM_ATTRIBUTE_OPTIONAL)
- MONO_OBJECT_SETREF (param, DefaultValueImpl, get_reflection_missing (domain, &missing));
- else
- MONO_OBJECT_SETREF (param, DefaultValueImpl, get_dbnull (domain, &dbnull, error));
- if (!is_ok (error))
- goto leave;
- }
+ if ((sig->params [i]->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT) != 0) {
+ any_default_value = TRUE;
+ break;
}
+ }
+ if (any_default_value) {
+ blobs = g_new0 (char *, sig->param_count);
+ types = g_new0 (guint32, sig->param_count);
+ get_default_param_value_blobs (method, blobs, types);
+ }
- if (mspecs [i + 1]) {
- MonoReflectionMarshalAsAttribute* mobj;
- mobj = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [i + 1], error);
- if (!mobj)
- goto leave;
- MONO_OBJECT_SETREF (param, MarshalAsImpl, (MonoObject*)mobj);
- }
-
- mono_array_setref (res, i, param);
+ /* Handles missing and dbnull are assigned in add_parameter_object_to_array when needed */
+ MonoObjectHandle missing = MONO_HANDLE_NEW (MonoObject, NULL);
+ MonoObjectHandle dbnull = MONO_HANDLE_NEW (MonoObject, NULL);
+ for (i = 0; i < sig->param_count; ++i) {
+ if (!add_parameter_object_to_array (domain, method, MONO_HANDLE_CAST(MonoObject, member), i, names[i], sig->params[i], types ? types[i] : 0, blobs ? blobs[i] : NULL, mspecs [i + 1], missing, dbnull, res, error))
+ goto leave;
}
leave:
g_free (names);
g_free (blobs);
g_free (types);
- g_free (type);
- if (sig) {
+ if (sig && mspecs) {
for (i = sig->param_count; i >= 0; i--) {
if (mspecs [i])
mono_metadata_free_marshal_spec (mspecs [i]);
* Return an System.Reflection.ParameterInfo array object representing the parameters
* in the method @method.
*/
-MonoArray*
+MonoArrayHandle
mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
{
mono_error_init (error);
+ /* side-effect: sets method->signature non-NULL on success */
MonoMethodSignature *sig = mono_method_signature_checked (method, error);
- if (!mono_error_ok (error))
- goto leave;
+ if (!is_ok (error))
+ goto fail;
if (!sig->param_count) {
- MonoArray *res = mono_array_new_checked (domain, mono_class_get_mono_parameter_info_class (), 0, error);
- if (!res)
- goto leave;
+ MonoArrayHandle res = mono_array_new_handle (domain, mono_class_get_mono_parameter_info_class (), 0, error);
+ if (!is_ok (error))
+ goto fail;
return res;
}
/* Note: the cache is based on the address of the signature into the method
* since we already cache MethodInfos with the method as keys.
*/
- return CHECK_OR_CONSTRUCT (MonoArray*, &method->signature, refclass, param_objects_construct, method);
-leave:
- return NULL;
+ return CHECK_OR_CONSTRUCT_HANDLE (MonoArrayHandle, &method->signature, refclass, param_objects_construct, method);
+fail:
+ return MONO_HANDLE_NEW (MonoArray, NULL_HANDLE);
}
MonoArray*
mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
{
+ HANDLE_FUNCTION_ENTER ();
MonoError error;
- MonoArray *result = mono_param_get_objects_internal (domain, method, NULL, &error);
+ MonoArrayHandle result = mono_param_get_objects_internal (domain, method, NULL, &error);
mono_error_assert_ok (&error);
- return result;
+ HANDLE_FUNCTION_RETURN_OBJ (result);
+}
+
+static gboolean
+add_local_var_info_to_array (MonoDomain *domain, MonoMethodHeader *header, int idx, MonoArrayHandle dest, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER ();
+ mono_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;
+
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, header->locals [idx], error);
+ if (!is_ok (error))
+ goto leave;
+
+ MONO_HANDLE_SET (info, local_type, rt);
+
+ MONO_HANDLE_SETVAL (info, is_pinned, MonoBoolean, header->locals [idx]->pinned);
+ MONO_HANDLE_SETVAL (info, local_index, guint16, idx);
+
+ MONO_HANDLE_ARRAY_SETREF (dest, idx, info);
+
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
+}
+
+static gboolean
+add_exception_handling_clause_to_array (MonoDomain *domain, MonoMethodHeader *header, int idx, MonoArrayHandle dest, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER ();
+ mono_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;
+ MonoExceptionClause *clause = &header->clauses [idx];
+
+ MONO_HANDLE_SETVAL (info, flags, gint32, clause->flags);
+ MONO_HANDLE_SETVAL (info, try_offset, gint32, clause->try_offset);
+ MONO_HANDLE_SETVAL (info, try_length, gint32, clause->try_len);
+ MONO_HANDLE_SETVAL (info, handler_offset, gint32, clause->handler_offset);
+ MONO_HANDLE_SETVAL (info, handler_length, gint32, clause->handler_len);
+ if (clause->flags == MONO_EXCEPTION_CLAUSE_FILTER)
+ MONO_HANDLE_SETVAL (info, filter_offset, gint32, clause->data.filter_offset);
+ else if (clause->data.catch_class) {
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (mono_domain_get (), &clause->data.catch_class->byval_arg, error);
+ if (!is_ok (error))
+ goto leave;
+
+ MONO_HANDLE_SET (info, catch_type, rt);
+ }
+
+ MONO_HANDLE_ARRAY_SETREF (dest, idx, info);
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
}
/*
MonoReflectionMethodBody*
mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
{
+ HANDLE_FUNCTION_ENTER ();
MonoError error;
- MonoReflectionMethodBody *result = mono_method_body_get_object_checked (domain, method, &error);
+ MonoReflectionMethodBodyHandle result = mono_method_body_get_object_handle (domain, method, &error);
mono_error_cleanup (&error);
- return result;
+ HANDLE_FUNCTION_RETURN_OBJ (result);
}
-static MonoReflectionMethodBody*
+static MonoReflectionMethodBodyHandle
method_body_object_construct (MonoDomain *domain, MonoClass *unused_class, MonoMethod *method, gpointer user_data, MonoError *error)
{
- MonoReflectionMethodBody *ret;
- MonoMethodHeader *header;
+ MonoMethodHeader *header = NULL;
MonoImage *image;
- MonoReflectionType *rt;
guint32 method_rva, local_var_sig_token;
char *ptr;
unsigned char format, flags;
/* for compatibility with .net */
if (method_is_dynamic (method)) {
mono_error_set_generic_error (error, "System", "InvalidOperationException", "");
- return NULL;
+ goto fail;
}
if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
(method->klass->image->raw_data && method->klass->image->raw_data [1] != 'Z') ||
(method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME))
- return NULL;
+ return MONO_HANDLE_CAST (MonoReflectionMethodBody, NULL_HANDLE);
image = method->klass->image;
header = mono_method_get_header_checked (method, error);
- return_val_if_nok (error, NULL);
+ if (!is_ok (error))
+ goto fail;
if (!image_is_dynamic (image)) {
/* Obtain local vars signature token */
} else
local_var_sig_token = 0; //FIXME
- ret = (MonoReflectionMethodBody*)mono_object_new_checked (domain, mono_class_get_method_body_class (), error);
+ MonoReflectionMethodBodyHandle ret = MONO_HANDLE_NEW (MonoReflectionMethodBody, mono_object_new_checked (domain, mono_class_get_method_body_class (), error));
if (!is_ok (error))
goto fail;
- ret->init_locals = header->init_locals;
- ret->max_stack = header->max_stack;
- ret->local_var_sig_token = local_var_sig_token;
- MonoArray *il_arr = mono_array_new_cached (domain, mono_defaults.byte_class, header->code_size, error);
+ MONO_HANDLE_SETVAL (ret, init_locals, MonoBoolean, header->init_locals);
+ MONO_HANDLE_SETVAL (ret, max_stack, guint32, header->max_stack);
+ MONO_HANDLE_SETVAL (ret, local_var_sig_token, guint32, local_var_sig_token);
+ MonoArrayHandle il_arr = mono_array_new_handle (domain, mono_defaults.byte_class, header->code_size, error);
if (!is_ok (error))
goto fail;
- MONO_OBJECT_SETREF (ret, il, il_arr);
- memcpy (mono_array_addr (ret->il, guint8, 0), header->code, header->code_size);
+ MONO_HANDLE_SET (ret, il, il_arr);
+ uint32_t il_gchandle;
+ guint8* il_data = MONO_ARRAY_HANDLE_PIN (il_arr, guint8, 0, &il_gchandle);
+ memcpy (il_data, header->code, header->code_size);
+ mono_gchandle_free (il_gchandle);
/* Locals */
- MonoArray *locals_arr = mono_array_new_cached (domain, mono_class_get_local_variable_info_class (), header->num_locals, error);
+ MonoArrayHandle locals_arr = mono_array_new_handle (domain, mono_class_get_local_variable_info_class (), header->num_locals, error);
if (!is_ok (error))
goto fail;
- MONO_OBJECT_SETREF (ret, locals, locals_arr);
+ MONO_HANDLE_SET (ret, locals, locals_arr);
for (i = 0; i < header->num_locals; ++i) {
- MonoReflectionLocalVariableInfo *info = (MonoReflectionLocalVariableInfo*)mono_object_new_checked (domain, mono_class_get_local_variable_info_class (), error);
- if (!is_ok (error))
- goto fail;
-
- rt = mono_type_get_object_checked (domain, header->locals [i], error);
- if (!is_ok (error))
+ if (!add_local_var_info_to_array (domain, header, i, locals_arr, error))
goto fail;
-
- MONO_OBJECT_SETREF (info, local_type, rt);
-
- info->is_pinned = header->locals [i]->pinned;
- info->local_index = i;
- mono_array_setref (ret->locals, i, info);
}
/* Exceptions */
- MonoArray *exn_clauses = mono_array_new_cached (domain, mono_class_get_exception_handling_clause_class (), header->num_clauses, error);
+ MonoArrayHandle exn_clauses = mono_array_new_handle (domain, mono_class_get_exception_handling_clause_class (), header->num_clauses, error);
if (!is_ok (error))
goto fail;
- MONO_OBJECT_SETREF (ret, clauses, exn_clauses);
+ MONO_HANDLE_SET (ret, clauses, exn_clauses);
for (i = 0; i < header->num_clauses; ++i) {
- MonoReflectionExceptionHandlingClause *info = (MonoReflectionExceptionHandlingClause*)mono_object_new_checked (domain, mono_class_get_exception_handling_clause_class (), error);
- if (!is_ok (error))
+ if (!add_exception_handling_clause_to_array (domain, header, i, exn_clauses, error))
goto fail;
- MonoExceptionClause *clause = &header->clauses [i];
-
- info->flags = clause->flags;
- info->try_offset = clause->try_offset;
- info->try_length = clause->try_len;
- info->handler_offset = clause->handler_offset;
- info->handler_length = clause->handler_len;
- if (clause->flags == MONO_EXCEPTION_CLAUSE_FILTER)
- info->filter_offset = clause->data.filter_offset;
- else if (clause->data.catch_class) {
- rt = mono_type_get_object_checked (mono_domain_get (), &clause->data.catch_class->byval_arg, error);
- if (!is_ok (error))
- goto fail;
-
- MONO_OBJECT_SETREF (info, catch_type, rt);
- }
-
- mono_array_setref (ret->clauses, i, info);
}
mono_metadata_free_mh (header);
return ret;
fail:
- mono_metadata_free_mh (header);
+ if (header)
+ mono_metadata_free_mh (header);
return NULL;
}
/**
- * mono_method_body_get_object_checked:
+ * mono_method_body_get_object_handle:
* @domain: an app domain
* @method: a method
* @error: set on error
* Return an System.Reflection.MethodBody object representing the
* method @method. On failure, returns NULL and sets @error.
*/
-MonoReflectionMethodBody*
-mono_method_body_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoError *error)
+MonoReflectionMethodBodyHandle
+mono_method_body_get_object_handle (MonoDomain *domain, MonoMethod *method, MonoError *error)
{
mono_error_init (error);
- return CHECK_OR_CONSTRUCT (MonoReflectionMethodBody *, method, NULL, method_body_object_construct, NULL);
+ return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionMethodBodyHandle, method, NULL, method_body_object_construct, NULL);
}
+
/**
* mono_get_dbnull_object:
* @domain: Domain where the object lives
MonoObject *
mono_get_dbnull_object (MonoDomain *domain)
{
+ HANDLE_FUNCTION_ENTER ();
MonoError error;
- MonoObject *obj;
-
- obj = get_dbnull_object (domain, &error);
+ MonoObjectHandle obj = get_dbnull_object (domain, &error);
mono_error_assert_ok (&error);
- return obj;
+ HANDLE_FUNCTION_RETURN_OBJ (obj);
}
static void
}
#endif /* !DISABLE_REFLECTION_EMIT */
-MonoReflectionMarshalAsAttribute*
+MonoReflectionMarshalAsAttributeHandle
mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass,
MonoMarshalSpec *spec, MonoError *error)
{
- MonoReflectionType *rt;
- MonoReflectionMarshalAsAttribute *minfo;
- MonoType *mtype;
-
mono_error_init (error);
- minfo = (MonoReflectionMarshalAsAttribute*)mono_object_new_checked (domain, mono_class_get_marshal_as_attribute_class (), error);
- if (!minfo)
- return NULL;
- minfo->utype = spec->native;
+ MonoReflectionMarshalAsAttributeHandle minfo = MONO_HANDLE_NEW (MonoReflectionMarshalAsAttribute, mono_object_new_checked (domain, mono_class_get_marshal_as_attribute_class (), error));
+ if (!is_ok (error))
+ goto fail;
+ guint32 utype = spec->native;
+ MONO_HANDLE_SETVAL (minfo, utype, guint32, utype);
- switch (minfo->utype) {
+ switch (utype) {
case MONO_NATIVE_LPARRAY:
- minfo->array_subtype = spec->data.array_data.elem_type;
- minfo->size_const = spec->data.array_data.num_elem;
+ MONO_HANDLE_SETVAL (minfo, array_subtype, guint32, spec->data.array_data.elem_type);
+ MONO_HANDLE_SETVAL (minfo, size_const, gint32, spec->data.array_data.num_elem);
if (spec->data.array_data.param_num != -1)
- minfo->size_param_index = spec->data.array_data.param_num;
+ MONO_HANDLE_SETVAL (minfo, size_param_index, gint16, spec->data.array_data.param_num);
break;
case MONO_NATIVE_BYVALTSTR:
case MONO_NATIVE_BYVALARRAY:
- minfo->size_const = spec->data.array_data.num_elem;
+ MONO_HANDLE_SETVAL (minfo, size_const, gint32, spec->data.array_data.num_elem);
break;
case MONO_NATIVE_CUSTOM:
if (spec->data.custom_data.custom_name) {
- mtype = mono_reflection_type_from_name_checked (spec->data.custom_data.custom_name, klass->image, error);
- return_val_if_nok (error, NULL);
+ MonoType *mtype = mono_reflection_type_from_name_checked (spec->data.custom_data.custom_name, klass->image, error);
+ if (!is_ok (error))
+ goto fail;
if (mtype) {
- rt = mono_type_get_object_checked (domain, mtype, error);
- if (!rt)
- return NULL;
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, mtype, error);
+ if (!is_ok (error))
+ goto fail;
- MONO_OBJECT_SETREF (minfo, marshal_type_ref, rt);
+ MONO_HANDLE_SET (minfo, marshal_type_ref, rt);
}
- MONO_OBJECT_SETREF (minfo, marshal_type, mono_string_new (domain, spec->data.custom_data.custom_name));
+ MonoStringHandle custom_name = mono_string_new_handle (domain, spec->data.custom_data.custom_name, error);
+ if (!is_ok (error))
+ goto fail;
+ MONO_HANDLE_SET (minfo, marshal_type, custom_name);
+ }
+ if (spec->data.custom_data.cookie) {
+ MonoStringHandle cookie = mono_string_new_handle (domain, spec->data.custom_data.cookie, error);
+ if (!is_ok (error))
+ goto fail;
+ MONO_HANDLE_SET (minfo, marshal_cookie, cookie);
}
- if (spec->data.custom_data.cookie)
- MONO_OBJECT_SETREF (minfo, marshal_cookie, mono_string_new (domain, spec->data.custom_data.cookie));
break;
default:
}
return minfo;
+fail:
+ return MONO_HANDLE_NEW (MonoReflectionMarshalAsAttribute, NULL);
}
#ifndef DISABLE_REFLECTION_EMIT
projects / mono.git / commitdiff