mono_image_property_insert (image, obj, MONO_PROP_DYNAMIC_CATTR, ainfo);
mono_loader_unlock ();
+}
+#else
+//FIXME some code compiled under DISABLE_REFLECTION_EMIT depends on this function, we should be more aggressively disabling things
+static void
+mono_save_custom_attrs (MonoImage *image, void *obj, MonoArray *cattrs)
+{
}
#endif
#ifndef DISABLE_REFLECTION_EMIT
static guint32
-mono_image_get_fieldref_token (MonoDynamicImage *assembly, MonoObjectHandle f, MonoClassField *field)
+mono_image_get_fieldref_token (MonoDynamicImage *assembly, MonoClassField *field)
{
MonoType *type;
guint32 token;
g_assert (field);
g_assert (field->parent);
- token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, MONO_HANDLE_RAW (f)));
+ token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, field));
if (token)
return token;
token = mono_image_get_memberref_token (assembly, &field->parent->byval_arg,
mono_field_get_name (field),
mono_dynimage_encode_fieldref_signature (assembly, field->parent->image, type));
- mono_g_hash_table_insert (assembly->handleref_managed, MONO_HANDLE_RAW (f), GUINT_TO_POINTER(token));
+ g_hash_table_insert (assembly->handleref, field, GUINT_TO_POINTER(token));
return token;
}
gboolean create_open_instance, gboolean register_token,
MonoError *error)
{
+ HANDLE_FUNCTION_ENTER ();
guint32 token = 0;
error_init (error);
MonoClass *klass = mono_handle_class (obj);
+ MonoObjectHandle register_obj = MONO_HANDLE_NEW (MonoObject, NULL);
+ MONO_HANDLE_ASSIGN (register_obj, obj);
/* Check for user defined reflection objects */
/* TypeDelegator is the only corlib type which doesn't look like a MonoReflectionType */
if (klass->image != mono_defaults.corlib || (strcmp (klass->name, "TypeDelegator") == 0)) {
mono_error_set_not_supported (error, "User defined subclasses of System.Type are not yet supported");
- return 0;
+ goto leave;
}
/* This function is called from ModuleBuilder:getToken multiple times for the same objects */
if (strcmp (klass->name, "RuntimeType") == 0) {
MonoType *type = mono_reflection_type_handle_mono_type (MONO_HANDLE_CAST (MonoReflectionType, obj), error);
- return_val_if_nok (error, 0);
+ if (!is_ok (error))
+ goto leave;
MonoClass *mc = mono_class_from_mono_type (type);
token = mono_metadata_token_from_dor (
mono_dynimage_encode_typedef_or_ref_full (assembly, type, !mono_class_is_gtd (mc) || create_open_instance));
token = MONO_TOKEN_FIELD_DEF | field_table_idx;
how_collide = MONO_DYN_IMAGE_TOK_NEW;
} else {
- token = mono_image_get_fieldref_token (assembly, obj, field);
+ token = mono_image_get_fieldref_token (assembly, field);
}
/*g_print ("got token 0x%08x for %s\n", token, f->field->name);*/
} else if (strcmp (klass->name, "MonoArrayMethod") == 0) {
MonoReflectionArrayMethodHandle m = MONO_HANDLE_CAST (MonoReflectionArrayMethod, obj);
- token = mono_image_get_array_token (assembly, m, error);
- return_val_if_nok (error, 0);
+ guint32 array_token = mono_image_get_array_token (assembly, m, error);
+ if (!is_ok (error))
+ goto leave;
+ token = array_token;
} else if (strcmp (klass->name, "SignatureHelper") == 0) {
MonoReflectionSigHelperHandle s = MONO_HANDLE_CAST (MonoReflectionSigHelper, obj);
- token = MONO_TOKEN_SIGNATURE | mono_image_get_sighelper_token (assembly, s, error);
- return_val_if_nok (error, 0);
+ guint32 sig_token = MONO_TOKEN_SIGNATURE | mono_image_get_sighelper_token (assembly, s, error);
+ if (!is_ok (error))
+ goto leave;
+ token = sig_token;
} else {
g_error ("requested token for %s\n", klass->name);
}
if (register_token)
- mono_dynamic_image_register_token (assembly, token, obj, how_collide);
+ mono_dynamic_image_register_token (assembly, token, register_obj, how_collide);
- return token;
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (token);
}
(rmb->iattrs & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
m = (MonoMethod *)image_g_new0 (image, MonoMethodPInvoke, 1);
else
- m = (MonoMethod *)image_g_new0 (image, MonoMethodWrapper, 1);
+ m = (MonoMethod *)image_g_new0 (image, MonoDynamicMethod, 1);
wrapperm = (MonoMethodWrapper*)m;
}
wrapperm->header = header;
+ MonoDynamicMethod *dm = (MonoDynamicMethod*)wrapperm;
+ dm->assembly = klass->image->assembly;
}
if (rmb->generic_params) {
rmb.refs [i + 1] = handle_class;
}
+ MonoAssembly *ass = NULL;
if (mb->owner) {
MonoType *owner_type = mono_reflection_type_get_handle ((MonoReflectionType*)mb->owner, error);
if (!is_ok (error)) {
return FALSE;
}
klass = mono_class_from_mono_type (owner_type);
+ ass = klass->image->assembly;
} else {
klass = mono_defaults.object_class;
+ ass = (mb->module && mb->module->image) ? mb->module->image->assembly : NULL;
}
mb->mhandle = handle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig, error);
+ ((MonoDynamicMethod*)handle)->assembly = ass;
g_free (rmb.refs);
return_val_if_nok (error, FALSE);
mono_reflection_dynimage_basic_init (assemblyb);
}
+void
+ves_icall_AssemblyBuilder_UpdateNativeCustomAttributes (MonoReflectionAssemblyBuilderHandle assemblyb, MonoError *error)
+{
+ MonoArrayHandle cattrs = MONO_HANDLE_NEW_GET (MonoArray, assemblyb, cattrs);
+
+ MonoReflectionAssemblyHandle assembly_handle = MONO_HANDLE_CAST (MonoReflectionAssembly, assemblyb);
+ MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_handle, assembly);
+ g_assert (assembly);
+
+ mono_save_custom_attrs (assembly->image, assembly, MONO_HANDLE_RAW (cattrs));
+}
+
void
ves_icall_EnumBuilder_setup_enum_type (MonoReflectionTypeHandle enumtype,
MonoReflectionTypeHandle t,
projects / mono.git / blobdiff