#include "mono/metadata/metadata-internals.h"
#include <mono/metadata/profiler-private.h>
#include "mono/metadata/class-internals.h"
-#include "mono/metadata/gc-internal.h"
+#include "mono/metadata/gc-internals.h"
#include "mono/metadata/tokentype.h"
#include "mono/metadata/domain-internals.h"
#include "mono/metadata/opcodes.h"
#include "image.h"
#include "cil-coff.h"
#include "mono-endian.h"
-#include <mono/metadata/gc-internal.h>
+#include <mono/metadata/gc-internals.h>
#include <mono/metadata/mempool-internals.h>
#include <mono/metadata/security-core-clr.h>
#include <mono/metadata/debug-helpers.h>
static MonoReflectionType *mono_reflection_type_get_underlying_system_type (MonoReflectionType* t);
static MonoType* mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve);
static MonoReflectionType* mono_reflection_type_resolve_user_types (MonoReflectionType *type);
-static gboolean is_sre_array (MonoClass *class);
-static gboolean is_sre_byref (MonoClass *class);
-static gboolean is_sre_pointer (MonoClass *class);
-static gboolean is_sre_type_builder (MonoClass *class);
-static gboolean is_sre_method_builder (MonoClass *class);
-static gboolean is_sre_ctor_builder (MonoClass *class);
-static gboolean is_sre_field_builder (MonoClass *class);
-static gboolean is_sr_mono_method (MonoClass *class);
-static gboolean is_sr_mono_cmethod (MonoClass *class);
-static gboolean is_sr_mono_generic_method (MonoClass *class);
-static gboolean is_sr_mono_generic_cmethod (MonoClass *class);
-static gboolean is_sr_mono_field (MonoClass *class);
-static gboolean is_sr_mono_property (MonoClass *class);
-static gboolean is_sre_method_on_tb_inst (MonoClass *class);
-static gboolean is_sre_ctor_on_tb_inst (MonoClass *class);
+static gboolean is_sre_array (MonoClass *klass);
+static gboolean is_sre_byref (MonoClass *klass);
+static gboolean is_sre_pointer (MonoClass *klass);
+static gboolean is_sre_type_builder (MonoClass *klass);
+static gboolean is_sre_method_builder (MonoClass *klass);
+static gboolean is_sre_ctor_builder (MonoClass *klass);
+static gboolean is_sre_field_builder (MonoClass *klass);
+static gboolean is_sr_mono_method (MonoClass *klass);
+static gboolean is_sr_mono_cmethod (MonoClass *klass);
+static gboolean is_sr_mono_generic_method (MonoClass *klass);
+static gboolean is_sr_mono_generic_cmethod (MonoClass *klass);
+static gboolean is_sr_mono_field (MonoClass *klass);
+static gboolean is_sr_mono_property (MonoClass *klass);
+static gboolean is_sre_method_on_tb_inst (MonoClass *klass);
+static gboolean is_sre_ctor_on_tb_inst (MonoClass *klass);
static guint32 mono_image_get_methodspec_token (MonoDynamicImage *assembly, MonoMethod *method);
static guint32 mono_image_get_inflated_method_token (MonoDynamicImage *assembly, MonoMethod *m);
static guint32 create_typespec (MonoDynamicImage *assembly, MonoType *type);
static void init_type_builder_generics (MonoObject *type);
-#define RESOLVE_TYPE(type) do { type = (void*)mono_reflection_type_resolve_user_types ((MonoReflectionType*)type); } while (0)
+#define RESOLVE_TYPE(type) do { type = (MonoObject *)mono_reflection_type_resolve_user_types ((MonoReflectionType*)type); } while (0)
#define RESOLVE_ARRAY_TYPE_ELEMENT(array, index) do { \
MonoReflectionType *__type = mono_array_get (array, MonoReflectionType*, index); \
__type = mono_reflection_type_resolve_user_types (__type); \
#define ADDP_IS_GREATER_OR_OVF(a, b, c) (((a) + (b) > (c)) || CHECK_ADDP_OVERFLOW_UN (a, b))
#define ADD_IS_GREATER_OR_OVF(a, b, c) (((a) + (b) > (c)) || CHECK_ADD4_OVERFLOW_UN (a, b))
+// The dynamic images list is only needed to support the mempool reference tracking feature in checked-build.
+static GPtrArray *dynamic_images;
+static mono_mutex_t dynamic_images_mutex;
+
+static inline void
+dynamic_images_lock (void)
+{
+ mono_os_mutex_lock (&dynamic_images_mutex);
+}
+
+static inline void
+dynamic_images_unlock (void)
+{
+ mono_os_mutex_unlock (&dynamic_images_mutex);
+}
+
+/**
+ * mono_find_dynamic_image_owner:
+ *
+ * Find the dynamic image, if any, which a given pointer is located in the memory of.
+ */
+MonoImage *
+mono_find_dynamic_image_owner (void *ptr)
+{
+ MonoImage *owner = NULL;
+ int i;
+
+ dynamic_images_lock ();
+
+ if (dynamic_images)
+ {
+ for (i = 0; !owner && i < dynamic_images->len; ++i) {
+ MonoImage *image = (MonoImage *)g_ptr_array_index (dynamic_images, i);
+ if (mono_mempool_contains_addr (image->mempool, ptr))
+ owner = image;
+ }
+ }
+
+ dynamic_images_unlock ();
+
+ return owner;
+}
void
mono_reflection_init (void)
{
+ mono_os_mutex_init (&dynamic_images_mutex);
}
static inline void
dynamic_image_lock (MonoDynamicImage *image)
{
- MONO_TRY_BLOCKING;
+ MONO_PREPARE_BLOCKING;
mono_image_lock ((MonoImage*)image);
- MONO_FINISH_TRY_BLOCKING;
+ MONO_FINISH_BLOCKING;
}
static inline void
MonoObject *obj;
dynamic_image_lock (assembly);
- obj = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
+ obj = (MonoObject *)mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
dynamic_image_unlock (assembly);
return obj;
{
MONO_REQ_GC_NEUTRAL_MODE;
- buf->buf = g_malloc (size);
+ buf->buf = (char *)g_malloc (size);
buf->p = buf->buf;
buf->end = buf->buf + size;
}
if (buf->end - buf->p < size) {
int new_size = buf->end - buf->buf + size + 32;
- char *p = g_realloc (buf->buf, new_size);
+ char *p = (char *)g_realloc (buf->buf, new_size);
size = buf->p - buf->buf;
buf->buf = p;
buf->p = p + size;
table->alloc_rows *= 2;
}
- table->values = g_renew (guint32, table->values, (table->alloc_rows) * table->columns);
+ table->values = (guint32 *)g_renew (guint32, table->values, (table->alloc_rows) * table->columns);
}
}
stream->alloc_size *= 2;
}
- stream->data = g_realloc (stream->data, stream->alloc_size);
+ stream->data = (char *)g_realloc (stream->data, stream->alloc_size);
}
static guint32
sh->index = 0;
sh->alloc_size = 4096;
- sh->data = g_malloc (4096);
+ sh->data = (char *)g_malloc (4096);
sh->hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
string_heap_insert (sh, "");
}
char *copy;
gpointer oldkey, oldval;
- copy = g_malloc (s1+s2);
+ copy = (char *)g_malloc (s1+s2);
memcpy (copy, b1, s1);
memcpy (copy + s1, b2, s2);
if (g_hash_table_lookup_extended (assembly->blob_cache, copy, &oldkey, &oldval)) {
MonoCustomAttrInfo* res;
- res = mono_image_property_lookup (image, member, MONO_PROP_DYNAMIC_CATTR);
+ res = (MonoCustomAttrInfo *)mono_image_property_lookup (image, member, MONO_PROP_DYNAMIC_CATTR);
if (!res)
return NULL;
- res = g_memdup (res, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * res->num_attrs);
+ res = (MonoCustomAttrInfo *)g_memdup (res, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * res->num_attrs);
res->cached = 0;
return res;
}
}
count -= not_visible;
- ainfo = image_g_malloc0 (alloc_img, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * count);
+ ainfo = (MonoCustomAttrInfo *)image_g_malloc0 (alloc_img, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * count);
ainfo->image = image;
ainfo->num_attrs = count;
for (i = 0; i < count; ++i) {
cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
if (custom_attr_visible (image, cattr)) {
- unsigned char *saved = mono_image_alloc (image, mono_array_length (cattr->data));
+ unsigned char *saved = (unsigned char *)mono_image_alloc (image, mono_array_length (cattr->data));
memcpy (saved, mono_array_addr (cattr->data, char, 0), mono_array_length (cattr->data));
ainfo->attrs [index].ctor = cattr->ctor->method;
ainfo->attrs [index].data = saved;
ainfo = mono_custom_attrs_from_builders (image, image, cattrs);
mono_loader_lock ();
- tmp = mono_image_property_lookup (image, obj, MONO_PROP_DYNAMIC_CATTR);
+ tmp = (MonoCustomAttrInfo *)mono_image_property_lookup (image, obj, MONO_PROP_DYNAMIC_CATTR);
if (tmp)
mono_custom_attrs_free (tmp);
mono_image_property_insert (image, obj, MONO_PROP_DYNAMIC_CATTR, ainfo);
guint32 owner = MONO_TYPEORMETHOD_METHOD | (mb->table_idx << MONO_TYPEORMETHOD_BITS);
mono_image_get_generic_param_info (
- mono_array_get (mb->generic_params, gpointer, i), owner, assembly);
+ (MonoReflectionGenericParam *)mono_array_get (mb->generic_params, gpointer, i), owner, assembly);
}
}
for (i = 0; i < type->num_mods; ++i) {
if (field_image) {
MonoError error;
- MonoClass *class = mono_class_get_checked (field_image, type->modifiers [i].token, &error);
+ MonoClass *klass = mono_class_get_checked (field_image, type->modifiers [i].token, &error);
g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
- token = mono_image_typedef_or_ref (assembly, &class->byval_arg);
+ token = mono_image_typedef_or_ref (assembly, &klass->byval_arg);
} else {
token = type->modifiers [i].token;
}
guint32 idx;
guint32 typespec = 0;
MonoType *type;
- MonoClass *class;
+ MonoClass *klass;
init_type_builder_generics (fb->type);
type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type);
- class = mono_class_from_mono_type (type);
+ klass = mono_class_from_mono_type (type);
sigbuffer_init (&buf, 32);
encode_custom_modifiers (assembly, fb->modreq, fb->modopt, &buf);
/* encode custom attributes before the type */
- if (class->generic_container)
+ if (klass->generic_container)
typespec = create_typespec (assembly, type);
if (typespec) {
MonoGenericClass *gclass;
- gclass = mono_metadata_lookup_generic_class (class, class->generic_container->context.class_inst, TRUE);
+ gclass = mono_metadata_lookup_generic_class (klass, klass->generic_container->context.class_inst, TRUE);
encode_generic_class (assembly, gclass, &buf);
} else {
encode_type (assembly, type, &buf);
}
static guint32
-encode_constant (MonoDynamicImage *assembly, MonoObject *val, guint32 *ret_type)
+encode_constant (MonoDynamicImage *assembly, MonoObject *val, MonoTypeEnum *ret_type)
{
MONO_REQ_GC_UNSAFE_MODE;
char* buf;
guint32 idx = 0, len = 0, dummy = 0;
- buf = g_malloc (64);
+ buf = (char *)g_malloc (64);
if (!val) {
*ret_type = MONO_TYPE_CLASS;
len = 4;
values [MONO_FIELD_LAYOUT_OFFSET] = fb->offset;
}
if (fb->attrs & FIELD_ATTRIBUTE_LITERAL) {
- guint32 field_type = 0;
+ MonoTypeEnum field_type = (MonoTypeEnum)0;
table = &assembly->tables [MONO_TABLE_CONSTANT];
table->rows ++;
alloc_table (table, table->rows);
values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
}
if (pb->attrs & PROPERTY_ATTRIBUTE_HAS_DEFAULT) {
- guint32 field_type = 0;
+ MonoTypeEnum field_type = (MonoTypeEnum)0;
table = &assembly->tables [MONO_TABLE_CONSTANT];
table->rows ++;
alloc_table (table, table->rows);
}
for (i = 0; i < num_constraints; i++) {
- MonoReflectionType *constraint = mono_array_get (
+ MonoReflectionType *constraint = (MonoReflectionType *)mono_array_get (
gparam->iface_constraints, gpointer, i);
table_idx = table->next_idx ++;
*/
if ((klass->image == &assembly->image) && (type->type != MONO_TYPE_VAR) &&
(type->type != MONO_TYPE_MVAR)) {
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
token = MONO_TYPEDEFORREF_TYPEDEF | (tb->table_idx << MONO_TYPEDEFORREF_BITS);
- register_dyn_token (assembly, token, mono_class_get_ref_info (klass));
+ register_dyn_token (assembly, token, (MonoObject *)mono_class_get_ref_info (klass));
return token;
}
token = MONO_TYPEDEFORREF_TYPEREF | (table->next_idx << MONO_TYPEDEFORREF_BITS); /* typeref */
g_hash_table_insert (assembly->typeref, type, GUINT_TO_POINTER(token));
table->next_idx ++;
- register_dyn_token (assembly, token, mono_class_get_ref_info (klass));
+ register_dyn_token (assembly, token, (MonoObject *)mono_class_get_ref_info (klass));
return token;
}
static MonoType*
get_field_on_inst_generic_type (MonoClassField *field)
{
- MonoClass *class, *gtd;
+ MonoClass *klass, *gtd;
MonoDynamicGenericClass *dgclass;
int field_index;
return dgclass->field_generic_types [field_index];
}
- class = field->parent;
- gtd = class->generic_class->container_class;
+ klass = field->parent;
+ gtd = klass->generic_class->container_class;
- if (field >= class->fields && field - class->fields < class->field.count) {
- field_index = field - class->fields;
+ if (field >= klass->fields && field - klass->fields < klass->field.count) {
+ field_index = field - klass->fields;
return gtd->fields [field_index].type;
}
type_argv = g_new0 (MonoType *, count);
for (i = 0; i < count; i++) {
- MonoReflectionType *garg = mono_array_get (m->method_args, gpointer, i);
+ MonoReflectionType *garg = (MonoReflectionType *)mono_array_get (m->method_args, gpointer, i);
type_argv [i] = mono_reflection_type_get_handle (garg);
}
ginst = mono_metadata_get_generic_inst (count, type_argv);
return mono_metadata_type_dup (NULL, type);
len = MONO_SIZEOF_TYPE + ((gint32)count) * sizeof (MonoCustomMod);
- t = g_malloc (len);
+ t = (MonoType *)g_malloc (len);
memcpy (t, type, MONO_SIZEOF_TYPE);
t->num_mods = count;
name = mono_string_to_utf8 (m->name);
nparams = mono_array_length (m->parameters);
- sig = g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * nparams);
+ sig = (MonoMethodSignature *)g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * nparams);
sig->hasthis = 1;
sig->sentinelpos = -1;
sig->call_convention = reflection_cc_to_file (m->call_conv);
sig->params [i] = mono_type_array_get_and_resolve (m->parameters, i);
for (tmp = assembly->array_methods; tmp; tmp = tmp->next) {
- am = tmp->data;
+ am = (ArrayMethod *)tmp->data;
if (strcmp (name, am->name) == 0 &&
mono_metadata_type_equal (am->parent, mtype) &&
mono_metadata_signature_equal (am->sig, sig)) {
GList *tmp;
for (tmp = klass->ext->nested_classes; tmp; tmp = tmp->next)
- mono_image_fill_export_table_from_class (domain, tmp->data, module_index, table->next_idx - 1, assembly);
+ mono_image_fill_export_table_from_class (domain, (MonoClass *)tmp->data, module_index, table->next_idx - 1, assembly);
}
return res;
static int
compare_constants (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
return a_values [MONO_CONSTANT_PARENT] - b_values [MONO_CONSTANT_PARENT];
}
static int
compare_semantics (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
int assoc = a_values [MONO_METHOD_SEMA_ASSOCIATION] - b_values [MONO_METHOD_SEMA_ASSOCIATION];
if (assoc)
return assoc;
static int
compare_custom_attrs (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
return a_values [MONO_CUSTOM_ATTR_PARENT] - b_values [MONO_CUSTOM_ATTR_PARENT];
}
static int
compare_field_marshal (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
return a_values [MONO_FIELD_MARSHAL_PARENT] - b_values [MONO_FIELD_MARSHAL_PARENT];
}
static int
compare_nested (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
return a_values [MONO_NESTED_CLASS_NESTED] - b_values [MONO_NESTED_CLASS_NESTED];
}
static int
compare_declsecurity_attrs (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
return a_values [MONO_DECL_SECURITY_PARENT] - b_values [MONO_DECL_SECURITY_PARENT];
}
static int
compare_interface_impl (const void *a, const void *b)
{
- const guint32 *a_values = a;
- const guint32 *b_values = b;
+ const guint32 *a_values = (const guint32 *)a;
+ const guint32 *b_values = (const guint32 *)b;
int klass = a_values [MONO_INTERFACEIMPL_CLASS] - b_values [MONO_INTERFACEIMPL_CLASS];
if (klass)
qsort (assembly->gen_params->pdata, assembly->gen_params->len, sizeof (gpointer), compare_genericparam);
for (i = 0; i < assembly->gen_params->len; i++){
- GenericParamTableEntry *entry = g_ptr_array_index (assembly->gen_params, i);
+ GenericParamTableEntry *entry = (GenericParamTableEntry *)g_ptr_array_index (assembly->gen_params, i);
write_generic_param_entry (assembly, entry);
}
heapt_size += 3;
heapt_size &= ~3;
meta_size += heapt_size;
- meta->raw_metadata = g_malloc0 (meta_size);
+ meta->raw_metadata = (char *)g_malloc0 (meta_size);
p = (unsigned char*)meta->raw_metadata;
/* the metadata signature */
*p++ = 'B'; *p++ = 'S'; *p++ = 'J'; *p++ = 'B';
if ((type & MONO_CUSTOM_ATTR_TYPE_MASK) == MONO_CUSTOM_ATTR_TYPE_METHODDEF) {
idx = type >> MONO_CUSTOM_ATTR_TYPE_BITS;
token = mono_metadata_make_token (MONO_TABLE_METHOD, idx);
- ctor = mono_g_hash_table_lookup (assembly->remapped_tokens, GUINT_TO_POINTER (token));
+ ctor = (MonoObject *)mono_g_hash_table_lookup (assembly->remapped_tokens, GUINT_TO_POINTER (token));
g_assert (ctor);
if (!strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
token = mono_image_add_stream_data (&assembly->blob, blob_size, b - blob_size);
mono_image_add_stream_data (&assembly->blob, mono_array_addr (pkey, char, 0), len);
- assembly->public_key = g_malloc (len);
+ assembly->public_key = (guint8 *)g_malloc (len);
memcpy (assembly->public_key, mono_array_addr (pkey, char, 0), len);
assembly->public_key_len = len;
g_warning ("Invalid public key length: %d bits (total: %d)", (int)MONO_PUBLIC_KEY_BIT_SIZE (len), (int)len);
assembly->strong_name_size = MONO_DEFAULT_PUBLIC_KEY_LENGTH; /* to be safe */
}
- assembly->strong_name = g_malloc0 (assembly->strong_name_size);
+ assembly->strong_name = (char *)g_malloc0 (assembly->strong_name_size);
return token;
}
collect_types (&types, type);
}
- mono_ptr_array_sort (types, (gpointer)compare_types_by_table_idx);
+ mono_ptr_array_sort (types, (int (*)(const void *, const void *))compare_types_by_table_idx);
table = &assembly->tables [MONO_TABLE_TYPEDEF];
table->rows += mono_ptr_array_size (types);
alloc_table (table, table->rows);
* so load_class_names () needs to touch fewer pages.
*/
for (i = 0; i < mono_ptr_array_size (types); ++i) {
- MonoReflectionTypeBuilder *tb = mono_ptr_array_get (types, i);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
string_heap_insert_mstring (&assembly->sheap, tb->nspace);
}
for (i = 0; i < mono_ptr_array_size (types); ++i) {
- MonoReflectionTypeBuilder *tb = mono_ptr_array_get (types, i);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
string_heap_insert_mstring (&assembly->sheap, tb->name);
}
for (i = 0; i < mono_ptr_array_size (types); ++i) {
- MonoReflectionTypeBuilder *type = mono_ptr_array_get (types, i);
+ MonoReflectionTypeBuilder *type = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
mono_image_get_type_info (domain, type, assembly);
}
}
for (i = 0; i < mono_ptr_array_size (types); ++i) {
- MonoReflectionTypeBuilder *type = mono_ptr_array_get (types, i);
+ MonoReflectionTypeBuilder *type = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
if (type->methods) {
for (j = 0; j < type->num_methods; ++j) {
MonoReflectionMethodBuilder *mb = mono_array_get (
MonoObject *prev;
dynamic_image_lock (assembly);
- prev = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
+ prev = (MonoObject *)mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
if (prev) {
/* There could be multiple MethodInfo objects with the same token */
//g_assert (prev == obj);
#if HAVE_BOEHM_GC
/* The MonoGHashTable's need GC tracking */
- image = GC_MALLOC (sizeof (MonoDynamicImage));
+ image = (MonoDynamicImage *)GC_MALLOC (sizeof (MonoDynamicImage));
#else
image = g_new0 (MonoDynamicImage, 1);
#endif
mono_profiler_module_loaded (&image->image, MONO_PROFILE_OK);
+ dynamic_images_lock ();
+
+ if (!dynamic_images)
+ dynamic_images = g_ptr_array_new ();
+
+ g_ptr_array_add (dynamic_images, image);
+
+ dynamic_images_unlock ();
+
return image;
}
#endif
release_hashtable (&image->methodspec);
}
+// Free dynamic image pass one: Free resources but not image itself
void
mono_dynamic_image_free (MonoDynamicImage *image)
{
g_list_free (di->array_methods);
if (di->gen_params) {
for (i = 0; i < di->gen_params->len; i++) {
- GenericParamTableEntry *entry = g_ptr_array_index (di->gen_params, i);
+ GenericParamTableEntry *entry = (GenericParamTableEntry *)g_ptr_array_index (di->gen_params, i);
mono_gc_deregister_root ((char*) &entry->gparam);
g_free (entry);
}
for (i = 0; i < MONO_TABLE_NUM; ++i) {
g_free (di->tables [i].values);
}
-}
+ dynamic_images_lock ();
+
+ if (dynamic_images)
+ g_ptr_array_remove (dynamic_images, di);
+
+ dynamic_images_unlock ();
+}
+
+// Free dynamic image pass two: Free image itself (might never get called in some debug modes)
void
mono_dynamic_image_free_image (MonoDynamicImage *image)
{
#if HAVE_BOEHM_GC
/* assembly->assembly.image might be GC allocated */
- assembly = assemblyb->dynamic_assembly = GC_MALLOC (sizeof (MonoDynamicAssembly));
+ assembly = assemblyb->dynamic_assembly = (MonoDynamicAssembly *)GC_MALLOC (sizeof (MonoDynamicAssembly));
#else
assembly = assemblyb->dynamic_assembly = g_new0 (MonoDynamicAssembly, 1);
#endif
}
/* Directory structure */
size += mono_array_length (assemblyb->win32_resources) * 256;
- p = buf = g_malloc (size);
+ p = buf = (char *)g_malloc (size);
resource_tree_encode (tree, p, p, &p);
g_assert (p - buf <= size);
- assembly->win32_res = g_malloc (p - buf);
+ assembly->win32_res = (char *)g_malloc (p - buf);
assembly->win32_res_size = p - buf;
memcpy (assembly->win32_res, buf, p - buf);
static gboolean
reflected_equal (gconstpointer a, gconstpointer b) {
- const ReflectedEntry *ea = a;
- const ReflectedEntry *eb = b;
+ const ReflectedEntry *ea = (const ReflectedEntry *)a;
+ const ReflectedEntry *eb = (const ReflectedEntry *)b;
return (ea->item == eb->item) && (ea->refclass == eb->refclass);
}
static guint
reflected_hash (gconstpointer a) {
- const ReflectedEntry *ea = a;
+ const ReflectedEntry *ea = (const ReflectedEntry *)a;
return mono_aligned_addr_hash (ea->item);
}
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"); \
- if ((_obj = mono_g_hash_table_lookup (domain->refobject_hash, &e))) { \
+ if ((_obj = (t)mono_g_hash_table_lookup (domain->refobject_hash, &e))) { \
mono_domain_unlock (domain); \
return _obj; \
} \
#define FREE_REFENTRY(entry) g_free ((entry))
#define REFENTRY_REQUIRES_CLEANUP
#else
-#define ALLOC_REFENTRY mono_mempool_alloc (domain->mp, sizeof (ReflectedEntry))
+#define ALLOC_REFENTRY (ReflectedEntry *)mono_mempool_alloc (domain->mp, sizeof (ReflectedEntry))
/* FIXME: */
#define FREE_REFENTRY(entry)
#endif
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"); \
- _obj = mono_g_hash_table_lookup (domain->refobject_hash, &pe); \
+ _obj = (t)mono_g_hash_table_lookup (domain->refobject_hash, &pe); \
if (!_obj) { \
ReflectedEntry *e = ALLOC_REFENTRY; \
e->item = (p); \
CHECK_OBJECT (MonoReflectionAssembly *, assembly, NULL);
if (!assembly_type) {
- MonoClass *class = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoAssembly");
- if (class == NULL)
- class = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Assembly");
- g_assert (class);
- assembly_type = class;
+ MonoClass *klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoAssembly");
+ if (klass == NULL)
+ klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Assembly");
+ g_assert (klass);
+ assembly_type = klass;
}
res = (MonoReflectionAssembly *)mono_object_new (domain, assembly_type);
res->assembly = assembly;
CHECK_OBJECT (MonoReflectionModule *, image, NULL);
if (!module_type) {
- MonoClass *class = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoModule");
- if (class == NULL)
- class = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Module");
- g_assert (class);
- module_type = class;
+ MonoClass *klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoModule");
+ if (klass == NULL)
+ klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Module");
+ g_assert (klass);
+ module_type = klass;
}
res = (MonoReflectionModule *)mono_object_new (domain, module_type);
const char *val;
if (!module_type) {
- MonoClass *class = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoModule");
- if (class == NULL)
- class = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Module");
- g_assert (class);
- module_type = class;
+ MonoClass *klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoModule");
+ if (klass == NULL)
+ klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Module");
+ g_assert (klass);
+ module_type = klass;
}
res = (MonoReflectionModule *)mono_object_new (domain, module_type);
if (type == &klass->byval_arg && !image_is_dynamic (klass->image)) {
MonoVTable *vtable = mono_class_try_get_vtable (domain, klass);
if (vtable && vtable->type)
- return vtable->type;
+ return (MonoReflectionType *)vtable->type;
}
mono_loader_lock (); /*FIXME mono_class_init and mono_class_vtable acquire it*/
if (!domain->type_hash)
domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mono_metadata_type_hash,
(GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection types table");
- if ((res = mono_g_hash_table_lookup (domain->type_hash, type))) {
+ if ((res = (MonoReflectionType *)mono_g_hash_table_lookup (domain->type_hash, type))) {
mono_domain_unlock (domain);
mono_loader_unlock ();
return res;
if (is_type_done && !type->byref) {
mono_domain_unlock (domain);
mono_loader_unlock ();
- return mono_class_get_ref_info (klass);
+ return (MonoReflectionType *)mono_class_get_ref_info (klass);
}
}
/* This is stored in vtables/JITted code so it has to be pinned */
/* Build MonoType for the type from the Constant Table */
if (!type)
type = g_new0 (MonoType, 1);
- type->type = types [i];
+ type->type = (MonoTypeEnum)types [i];
type->data.klass = NULL;
if (types [i] == MONO_TYPE_CLASS)
type->data.klass = mono_defaults.object_class;
if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
(method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
(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;
MonoReflectionMethodAux *aux;
if (method->is_inflated)
method = ((MonoMethodInflated*)method)->declaring;
- aux = g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
+ aux = (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
if (aux && aux->param_defaults) {
memcpy (blobs, &(aux->param_defaults [1]), methodsig->param_count * sizeof (char*));
memcpy (types, &(aux->param_default_types [1]), methodsig->param_count * sizeof (guint32));
}
mono_metadata_decode_row (constt, crow - 1, const_cols, MONO_CONSTANT_SIZE);
- blobs [paramseq - 1] = (gpointer) mono_metadata_blob_heap (image, const_cols [MONO_CONSTANT_VALUE]);
+ blobs [paramseq - 1] = (char *)mono_metadata_blob_heap (image, const_cols [MONO_CONSTANT_VALUE]);
types [paramseq - 1] = const_cols [MONO_CONSTANT_TYPE];
}
{
char *start, *p, *w, *last_point, *startn;
int in_modifiers = 0;
- int isbyref = 0, rank = 0;
+ int isbyref = 0, rank = 0, isptr = 0;
start = p = w = name;
if (isbyref) /* only one level allowed by the spec */
return 0;
isbyref = 1;
+ isptr = 0;
info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (0));
*p++ = 0;
break;
case '*':
+ if (isbyref) /* pointer to ref not okay */
+ return 0;
info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (-1));
+ isptr = 1;
*p++ = 0;
break;
case '[':
+ if (isbyref) /* array of ref and generic ref are not okay */
+ return 0;
//Decide if it's an array of a generic argument list
*p++ = 0;
if (!*p) //XXX test
return 0;
if (*p == ',' || *p == '*' || *p == ']') { //array
+ isptr = 0;
rank = 1;
while (*p) {
if (*p == ']')
return 0;
info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (rank));
} else {
- if (rank) /* generic args after array spec*/ //XXX test
+ if (rank || isptr) /* generic args after array spec or ptr*/ //XXX test
return 0;
+ isptr = 0;
info->type_arguments = g_ptr_array_new ();
while (*p) {
MonoTypeNameParse *subinfo = g_new0 (MonoTypeNameParse, 1);
return 1;
}
+
+/**
+ * mono_identifier_unescape_type_name_chars:
+ * @identifier: the display name of a mono type
+ *
+ * Returns:
+ * The name in internal form, that is without escaping backslashes.
+ *
+ * The string is modified in place!
+ */
+char*
+mono_identifier_unescape_type_name_chars(char* identifier)
+{
+ char *w, *r;
+ if (!identifier)
+ return NULL;
+ for (w = r = identifier; *r != 0; r++)
+ {
+ char c = *r;
+ if (c == '\\') {
+ r++;
+ if (*r == 0)
+ break;
+ c = *r;
+ }
+ *w = c;
+ w++;
+ }
+ if (w != r)
+ *w = 0;
+ return identifier;
+}
+
+void
+mono_identifier_unescape_info (MonoTypeNameParse* info);
+
+static void
+unescape_each_type_argument(void* data, void* user_data)
+{
+ MonoTypeNameParse* info = (MonoTypeNameParse*)data;
+ mono_identifier_unescape_info (info);
+}
+
+static void
+unescape_each_nested_name (void* data, void* user_data)
+{
+ char* nested_name = (char*) data;
+ mono_identifier_unescape_type_name_chars(nested_name);
+}
+
+/**
+ * mono_identifier_unescape_info:
+ *
+ * @info: a parsed display form of an (optionally assembly qualified) full type name.
+ *
+ * Returns: nothing.
+ *
+ * Destructively updates the info by unescaping the identifiers that
+ * comprise the type namespace, name, nested types (if any) and
+ * generic type arguments (if any).
+ *
+ * The resulting info has the names in internal form.
+ *
+ */
+void
+mono_identifier_unescape_info (MonoTypeNameParse *info)
+{
+ if (!info)
+ return;
+ mono_identifier_unescape_type_name_chars(info->name_space);
+ mono_identifier_unescape_type_name_chars(info->name);
+ // but don't escape info->assembly
+ if (info->type_arguments)
+ g_ptr_array_foreach(info->type_arguments, &unescape_each_type_argument, NULL);
+ if (info->nested)
+ g_list_foreach(info->nested, &unescape_each_nested_name, NULL);
+}
+
int
mono_reflection_parse_type (char *name, MonoTypeNameParse *info)
{
- return _mono_reflection_parse_type (name, NULL, FALSE, info);
+ int ok = _mono_reflection_parse_type (name, NULL, FALSE, info);
+ if (ok) {
+ mono_identifier_unescape_info (info);
+ }
+ return ok;
}
static MonoType*
char *nested_name, *nested_nspace;
gboolean match = TRUE;
- lastp = strrchr (mod->data, '.');
+ lastp = strrchr ((const char *)mod->data, '.');
if (lastp) {
/* Nested classes can have namespaces */
int nspace_len;
nested_name = g_strdup (lastp + 1);
nspace_len = lastp - (char*)mod->data;
- nested_nspace = g_malloc (nspace_len + 1);
+ nested_nspace = (char *)g_malloc (nspace_len + 1);
memcpy (nested_nspace, mod->data, nspace_len);
nested_nspace [nspace_len] = '\0';
} else {
- nested_name = mod->data;
+ nested_name = (char *)mod->data;
nested_nspace = NULL;
}
int i;
for (i = 0; i < info->type_arguments->len; i++) {
- MonoTypeNameParse *subinfo = g_ptr_array_index (info->type_arguments, i);
+ MonoTypeNameParse *subinfo = (MonoTypeNameParse *)g_ptr_array_index (info->type_arguments, i);
type_args [i] = _mono_reflection_get_type_from_info (subinfo, rootimage, ignorecase);
if (!type_args [i]) {
int i;
for (i = 0; i < info->type_arguments->len; i++) {
- MonoTypeNameParse *subinfo = g_ptr_array_index (info->type_arguments, i);
+ MonoTypeNameParse *subinfo = (MonoTypeNameParse *)g_ptr_array_index (info->type_arguments, i);
mono_reflection_free_type_info (subinfo);
/*We free the subinfo since it is allocated by _mono_reflection_parse_type*/
mono_error_init (error);
- n = g_memdup (p, slen + 1);
+ n = (char *)g_memdup (p, slen + 1);
n [slen] = 0;
t = mono_reflection_type_from_name (n, image);
if (!t) {
case MONO_TYPE_U1:
case MONO_TYPE_I1:
case MONO_TYPE_BOOLEAN: {
- MonoBoolean *bval = g_malloc (sizeof (MonoBoolean));
+ MonoBoolean *bval = (MonoBoolean *)g_malloc (sizeof (MonoBoolean));
*bval = *p;
*end = p + 1;
return bval;
case MONO_TYPE_CHAR:
case MONO_TYPE_U2:
case MONO_TYPE_I2: {
- guint16 *val = g_malloc (sizeof (guint16));
+ guint16 *val = (guint16 *)g_malloc (sizeof (guint16));
*val = read16 (p);
*end = p + 2;
return val;
case MONO_TYPE_R4:
case MONO_TYPE_U4:
case MONO_TYPE_I4: {
- guint32 *val = g_malloc (sizeof (guint32));
+ guint32 *val = (guint32 *)g_malloc (sizeof (guint32));
*val = read32 (p);
*end = p + 4;
return val;
#endif
case MONO_TYPE_U8:
case MONO_TYPE_I8: {
- guint64 *val = g_malloc (sizeof (guint64));
+ guint64 *val = (guint64 *)g_malloc (sizeof (guint64));
*val = read64 (p);
*end = p + 8;
return val;
}
case MONO_TYPE_R8: {
- double *val = g_malloc (sizeof (double));
+ double *val = (double *)g_malloc (sizeof (double));
readr8 (p, val);
*end = p + 8;
return val;
MonoClass *k = t->data.klass;
if (mono_is_corlib_image (k->image) && strcmp (k->name_space, "System") == 0 && strcmp (k->name, "DateTime") == 0){
- guint64 *val = g_malloc (sizeof (guint64));
+ guint64 *val = (guint64 *)g_malloc (sizeof (guint64));
*val = read64 (p);
*end = p + 8;
return val;
}
handle_type:
slen = mono_metadata_decode_value (p, &p);
- n = g_memdup (p, slen + 1);
+ n = (char *)g_memdup (p, slen + 1);
n [slen] = 0;
t = mono_reflection_type_from_name (n, image);
if (!t) {
if (etype == 0x51)
/* See Partition II, Appendix B3 */
etype = MONO_TYPE_OBJECT;
- simple_type.type = etype;
+ simple_type.type = (MonoTypeEnum)etype;
tklass = mono_class_from_mono_type (&simple_type);
}
goto handle_enum;
char *n;
MonoType *t;
slen = mono_metadata_decode_value (p, &p);
- n = g_memdup (p, slen + 1);
+ n = (char *)g_memdup (p, slen + 1);
n [slen] = 0;
t = mono_reflection_type_from_name (n, image);
if (!t) {
subc = mono_class_from_mono_type (t);
} else if (subt >= MONO_TYPE_BOOLEAN && subt <= MONO_TYPE_R8) {
MonoType simple_type = {{0}};
- simple_type.type = subt;
+ simple_type.type = (MonoTypeEnum)subt;
subc = mono_class_from_mono_type (&simple_type);
} else {
g_error ("Unknown type 0x%02x for object type encoding in custom attr", subt);
case MONO_TYPE_STRING:
case MONO_TYPE_SZARRAY:
for (i = 0; i < alen; i++) {
- MonoObject *item = load_cattr_value (image, &tklass->byval_arg, p, &p, error);
+ MonoObject *item = (MonoObject *)load_cattr_value (image, &tklass->byval_arg, p, &p, error);
if (!mono_error_ok (error))
return NULL;
mono_array_setref (arr, i, item);
memset (params, 0, sizeof (void*) * sig->param_count);
} else {
/* Allocate using GC so it gets GC tracking */
- params = mono_gc_alloc_fixed (sig->param_count * sizeof (void*), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_REFLECTION, "custom attribute parameters");
+ params = (void **)mono_gc_alloc_fixed (sig->param_count * sizeof (void*), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_REFLECTION, "custom attribute parameters");
}
/* skip prolog */
gint type_len;
char *type_name;
type_len = mono_metadata_decode_blob_size (named, &named);
- type_name = g_malloc (type_len + 1);
+ type_name = (char *)g_malloc (type_len + 1);
memcpy (type_name, named, type_len);
type_name [type_len] = 0;
named += type_len;
g_free (type_name);
}
name_len = mono_metadata_decode_blob_size (named, &named);
- name = g_malloc (name_len + 1);
+ name = (char *)g_malloc (name_len + 1);
memcpy (name, named, name_len);
name [name_len] = 0;
named += name_len;
return;
}
- obj = type_is_reference (mono_method_signature (method)->params [i]) ?
- val : mono_value_box (domain, mono_class_from_mono_type (mono_method_signature (method)->params [i]), val);
+ obj = (MonoObject *)(type_is_reference (mono_method_signature (method)->params [i]) ?
+ val : mono_value_box (domain, mono_class_from_mono_type (mono_method_signature (method)->params [i]), val));
mono_array_setref (typedargs, i, obj);
if (!type_is_reference (mono_method_signature (method)->params [i]))
if (ADDP_IS_GREATER_OR_OVF ((const guchar*)named, type_len, data + len))
goto fail;
- type_name = g_malloc (type_len + 1);
+ type_name = (char *)g_malloc (type_len + 1);
memcpy (type_name, named, type_len);
type_name [type_len] = 0;
named += type_len;
name_len = mono_metadata_decode_blob_size (named, &named);
if (ADDP_IS_GREATER_OR_OVF ((const guchar*)named, name_len, data + len))
goto fail;
- name = g_malloc (name_len + 1);
+ name = (char *)g_malloc (name_len + 1);
memcpy (name, named, name_len);
name [name_len] = 0;
named += name_len;
return;
}
- obj = type_is_reference (field->type) ? val : mono_value_box (domain, mono_class_from_mono_type (field->type), val);
+ obj = (MonoObject *)(type_is_reference (field->type) ? val : mono_value_box (domain, mono_class_from_mono_type (field->type), val));
mono_array_setref (namedargs, j, obj);
if (!type_is_reference (field->type))
g_free (val);
return;
}
- obj = type_is_reference (prop_type) ? val : mono_value_box (domain, mono_class_from_mono_type (prop_type), val);
+ obj = (MonoObject *)(type_is_reference (prop_type) ? val : mono_value_box (domain, mono_class_from_mono_type (prop_type), val));
mono_array_setref (namedargs, j, obj);
if (!type_is_reference (prop_type))
g_free (val);
if (!mono_class_init (method->klass))
mono_raise_exception (mono_class_get_exception_for_failure (method->klass));
- mono_reflection_create_custom_attr_data_args (image, method, data, len, &typedargs, &namedargs, &arginfo, &error);
+ mono_reflection_create_custom_attr_data_args (image, method, (const guchar *)data, len, &typedargs, &namedargs, &arginfo, &error);
if (!mono_error_ok (&error))
mono_error_raise_exception (&error);
if (mono_loader_get_last_error ())
len = g_list_length (list);
if (!len)
return NULL;
- ainfo = g_malloc0 (MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * len);
+ ainfo = (MonoCustomAttrInfo *)g_malloc0 (MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * len);
ainfo->num_attrs = len;
ainfo->image = image;
for (i = len, tmp = list; i != 0; --i, tmp = tmp->next) {
MonoCustomAttrInfo *res, *ainfo;
int size;
- aux = g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
+ aux = (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
if (!aux || !aux->param_cattr)
return NULL;
if (!ainfo)
return NULL;
size = MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * ainfo->num_attrs;
- res = g_malloc0 (size);
+ res = (MonoCustomAttrInfo *)g_malloc0 (size);
memcpy (res, ainfo, size);
return res;
}
static gboolean
-is_corlib_type (MonoClass *class)
+is_corlib_type (MonoClass *klass)
{
- return class->image == mono_defaults.corlib;
+ return klass->image == mono_defaults.corlib;
}
#define check_corlib_type_cached(_class, _namespace, _name) do { \
#ifndef DISABLE_REFLECTION_EMIT
static gboolean
-is_sre_array (MonoClass *class)
+is_sre_array (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection.Emit", "ArrayType");
+ check_corlib_type_cached (klass, "System.Reflection.Emit", "ArrayType");
}
static gboolean
-is_sre_byref (MonoClass *class)
+is_sre_byref (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection.Emit", "ByRefType");
+ check_corlib_type_cached (klass, "System.Reflection.Emit", "ByRefType");
}
static gboolean
-is_sre_pointer (MonoClass *class)
+is_sre_pointer (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection.Emit", "PointerType");
+ check_corlib_type_cached (klass, "System.Reflection.Emit", "PointerType");
}
static gboolean
-is_sre_generic_instance (MonoClass *class)
+is_sre_generic_instance (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection", "MonoGenericClass");
+ check_corlib_type_cached (klass, "System.Reflection", "MonoGenericClass");
}
static gboolean
-is_sre_type_builder (MonoClass *class)
+is_sre_type_builder (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection.Emit", "TypeBuilder");
+ check_corlib_type_cached (klass, "System.Reflection.Emit", "TypeBuilder");
}
static gboolean
-is_sre_method_builder (MonoClass *class)
+is_sre_method_builder (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection.Emit", "MethodBuilder");
+ check_corlib_type_cached (klass, "System.Reflection.Emit", "MethodBuilder");
}
static gboolean
-is_sre_ctor_builder (MonoClass *class)
+is_sre_ctor_builder (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection.Emit", "ConstructorBuilder");
+ check_corlib_type_cached (klass, "System.Reflection.Emit", "ConstructorBuilder");
}
static gboolean
-is_sre_field_builder (MonoClass *class)
+is_sre_field_builder (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection.Emit", "FieldBuilder");
+ check_corlib_type_cached (klass, "System.Reflection.Emit", "FieldBuilder");
}
static gboolean
-is_sre_method_on_tb_inst (MonoClass *class)
+is_sre_method_on_tb_inst (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection.Emit", "MethodOnTypeBuilderInst");
+ check_corlib_type_cached (klass, "System.Reflection.Emit", "MethodOnTypeBuilderInst");
}
static gboolean
-is_sre_ctor_on_tb_inst (MonoClass *class)
+is_sre_ctor_on_tb_inst (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection.Emit", "ConstructorOnTypeBuilderInst");
+ check_corlib_type_cached (klass, "System.Reflection.Emit", "ConstructorOnTypeBuilderInst");
}
MonoType*
mono_reflection_type_get_handle (MonoReflectionType* ref)
{
- MonoClass *class;
+ MonoClass *klass;
if (!ref)
return NULL;
if (ref->type)
return ref->type;
}
- class = mono_object_class (ref);
+ klass = mono_object_class (ref);
- if (is_sre_array (class)) {
+ if (is_sre_array (klass)) {
MonoType *res;
MonoReflectionArrayType *sre_array = (MonoReflectionArrayType*)ref;
MonoType *base = mono_reflection_type_get_handle (sre_array->element_type);
res = &mono_bounded_array_class_get (mono_class_from_mono_type (base), sre_array->rank, TRUE)->byval_arg;
sre_array->type.type = res;
return res;
- } else if (is_sre_byref (class)) {
+ } else if (is_sre_byref (klass)) {
MonoType *res;
MonoReflectionDerivedType *sre_byref = (MonoReflectionDerivedType*)ref;
MonoType *base = mono_reflection_type_get_handle (sre_byref->element_type);
res = &mono_class_from_mono_type (base)->this_arg;
sre_byref->type.type = res;
return res;
- } else if (is_sre_pointer (class)) {
+ } else if (is_sre_pointer (klass)) {
MonoType *res;
MonoReflectionDerivedType *sre_pointer = (MonoReflectionDerivedType*)ref;
MonoType *base = mono_reflection_type_get_handle (sre_pointer->element_type);
res = &mono_ptr_class_get (base)->byval_arg;
sre_pointer->type.type = res;
return res;
- } else if (is_sre_generic_instance (class)) {
+ } else if (is_sre_generic_instance (klass)) {
MonoType *res, **types;
MonoReflectionGenericClass *gclass = (MonoReflectionGenericClass*)ref;
int i, count;
count = mono_array_length (gclass->type_arguments);
types = g_new0 (MonoType*, count);
for (i = 0; i < count; ++i) {
- MonoReflectionType *t = mono_array_get (gclass->type_arguments, gpointer, i);
+ MonoReflectionType *t = (MonoReflectionType *)mono_array_get (gclass->type_arguments, gpointer, i);
types [i] = mono_reflection_type_get_handle (t);
if (!types[i]) {
g_free (types);
{
MonoType *res = mono_reflection_type_get_handle (type);
MonoDomain *domain = mono_object_domain ((MonoObject*)type);
- MonoClass *class;
+ MonoClass *klass;
if (!res)
mono_raise_exception (mono_get_exception_argument (NULL, "Invalid generic instantiation, one or more arguments are not proper user types"));
- class = mono_class_from_mono_type (res);
+ klass = mono_class_from_mono_type (res);
mono_loader_lock (); /*same locking as mono_type_get_object*/
mono_domain_lock (domain);
- if (!image_is_dynamic (class->image)) {
- mono_class_setup_supertypes (class);
+ if (!image_is_dynamic (klass->image)) {
+ mono_class_setup_supertypes (klass);
} else {
if (!domain->type_hash)
domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mono_metadata_type_hash,
count = parameters? mono_array_length (parameters): 0;
- sig = image_g_malloc0 (image, MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * count);
+ sig = (MonoMethodSignature *)image_g_malloc0 (image, MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * count);
sig->param_count = count;
sig->sentinelpos = -1; /* FIXME */
for (i = 0; i < count; ++i)
}
static gboolean
-is_sre_type_builder (MonoClass *class)
+is_sre_type_builder (MonoClass *klass)
{
return FALSE;
}
static gboolean
-is_sre_generic_instance (MonoClass *class)
+is_sre_generic_instance (MonoClass *klass)
{
return FALSE;
}
static gboolean
-is_sr_mono_field (MonoClass *class)
+is_sr_mono_field (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection", "MonoField");
+ check_corlib_type_cached (klass, "System.Reflection", "MonoField");
}
static gboolean
-is_sr_mono_property (MonoClass *class)
+is_sr_mono_property (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection", "MonoProperty");
+ check_corlib_type_cached (klass, "System.Reflection", "MonoProperty");
}
static gboolean
-is_sr_mono_method (MonoClass *class)
+is_sr_mono_method (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection", "MonoMethod");
+ check_corlib_type_cached (klass, "System.Reflection", "MonoMethod");
}
static gboolean
-is_sr_mono_cmethod (MonoClass *class)
+is_sr_mono_cmethod (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection", "MonoCMethod");
+ check_corlib_type_cached (klass, "System.Reflection", "MonoCMethod");
}
static gboolean
-is_sr_mono_generic_method (MonoClass *class)
+is_sr_mono_generic_method (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection", "MonoGenericMethod");
+ check_corlib_type_cached (klass, "System.Reflection", "MonoGenericMethod");
}
static gboolean
-is_sr_mono_generic_cmethod (MonoClass *class)
+is_sr_mono_generic_cmethod (MonoClass *klass)
{
- check_corlib_type_cached (class, "System.Reflection", "MonoGenericCMethod");
+ check_corlib_type_cached (klass, "System.Reflection", "MonoGenericCMethod");
}
gboolean
-mono_class_is_reflection_method_or_constructor (MonoClass *class)
+mono_class_is_reflection_method_or_constructor (MonoClass *klass)
{
- return is_sr_mono_method (class) || is_sr_mono_cmethod (class) || is_sr_mono_generic_method (class) || is_sr_mono_generic_cmethod (class);
+ return is_sr_mono_method (klass) || is_sr_mono_cmethod (klass) || is_sr_mono_generic_method (klass) || is_sr_mono_generic_cmethod (klass);
}
static gboolean
is_usertype (MonoReflectionType *ref)
{
- MonoClass *class = mono_object_class (ref);
- return class->image != mono_defaults.corlib || strcmp ("TypeDelegator", class->name) == 0;
+ MonoClass *klass = mono_object_class (ref);
+ return klass->image != mono_defaults.corlib || strcmp ("TypeDelegator", klass->name) == 0;
}
static MonoReflectionType*
if ((p-buffer) + 10 >= *buflen) {
char *newbuf;
*buflen *= 2;
- newbuf = g_realloc (buffer, *buflen);
+ newbuf = (char *)g_realloc (buffer, *buflen);
p = newbuf + (p-buffer);
buffer = newbuf;
}
char *newbuf;
*buflen *= 2;
*buflen += slen;
- newbuf = g_realloc (buffer, *buflen);
+ newbuf = (char *)g_realloc (buffer, *buflen);
p = newbuf + (p-buffer);
buffer = newbuf;
}
char *newbuf;
*buflen *= 2;
*buflen += slen;
- newbuf = g_realloc (buffer, *buflen);
+ newbuf = (char *)g_realloc (buffer, *buflen);
p = newbuf + (p-buffer);
buffer = newbuf;
}
char *newbuf;
*buflen *= 2;
*buflen += slen;
- newbuf = g_realloc (buffer, *buflen);
+ newbuf = (char *)g_realloc (buffer, *buflen);
p = newbuf + (p-buffer);
buffer = newbuf;
}
char *newbuf;
*buflen *= 2;
*buflen += len;
- newbuf = g_realloc (buffer, *buflen);
+ newbuf = (char *)g_realloc (buffer, *buflen);
p = newbuf + (p-buffer);
buffer = newbuf;
}
g_assert (mono_array_length (ctorArgs) == sig->param_count);
buflen = 256;
- p = buffer = g_malloc (buflen);
+ p = buffer = (char *)g_malloc (buflen);
/* write the prolog */
*p++ = 1;
*p++ = 0;
MonoType *ptype;
char *pname;
- prop = mono_array_get (properties, gpointer, i);
+ prop = (MonoObject *)mono_array_get (properties, gpointer, i);
get_prop_name_and_type (prop, &pname, &ptype);
*p++ = 0x54; /* PROPERTY signature */
encode_named_val (assembly, buffer, p, &buffer, &p, &buflen, ptype, pname, (MonoObject*)mono_array_get (propValues, gpointer, i));
MonoType *ftype;
char *fname;
- field = mono_array_get (fields, gpointer, i);
+ field = (MonoObject *)mono_array_get (fields, gpointer, i);
get_field_name_and_type (field, &fname, &ftype);
*p++ = 0x53; /* FIELD signature */
encode_named_val (assembly, buffer, p, &buffer, &p, &buflen, ftype, fname, (MonoObject*)mono_array_get (fieldValues, gpointer, i));
return;
}
- klass = mono_image_alloc0 (&tb->module->dynamic_image->image, sizeof (MonoClass));
+ klass = (MonoClass *)mono_image_alloc0 (&tb->module->dynamic_image->image, sizeof (MonoClass));
klass->image = &tb->module->dynamic_image->image;
g_assert (tb->generic_container && (tb->generic_container->owner.klass == klass));
- klass->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
+ klass->generic_container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
klass->generic_container->owner.klass = klass;
klass->generic_container->type_argc = count;
- klass->generic_container->type_params = mono_image_alloc0 (klass->image, sizeof (MonoGenericParamFull) * count);
+ klass->generic_container->type_params = (MonoGenericParamFull *)mono_image_alloc0 (klass->image, sizeof (MonoGenericParamFull) * count);
klass->is_generic = 1;
for (i = 0; i < count; i++) {
- MonoReflectionGenericParam *gparam = mono_array_get (tb->generic_params, gpointer, i);
+ MonoReflectionGenericParam *gparam = (MonoReflectionGenericParam *)mono_array_get (tb->generic_params, gpointer, i);
MonoGenericParamFull *param = (MonoGenericParamFull *) mono_reflection_type_get_handle ((MonoReflectionType*)gparam)->data.generic_param;
klass->generic_container->type_params [i] = *param;
/*Make sure we are a diferent type instance */
MonoMarshalSpec *res;
res = image_g_new0 (image, MonoMarshalSpec, 1);
- res->native = minfo->type;
+ res->native = (MonoMarshalNative)minfo->type;
switch (minfo->type) {
case MONO_NATIVE_LPARRAY:
- res->data.array_data.elem_type = minfo->eltype;
+ res->data.array_data.elem_type = (MonoMarshalNative)minfo->eltype;
if (minfo->has_size) {
res->data.array_data.param_num = minfo->param_num;
res->data.array_data.num_elem = minfo->count;
}
}
- header = image_g_malloc0 (image, MONO_SIZEOF_METHOD_HEADER + num_locals * sizeof (MonoType*));
+ header = (MonoMethodHeader *)image_g_malloc0 (image, MONO_SIZEOF_METHOD_HEADER + num_locals * sizeof (MonoType*));
header->code_size = code_size;
- header->code = image_g_malloc (image, code_size);
+ header->code = (const unsigned char *)image_g_malloc (image, code_size);
memcpy ((char*)header->code, code, code_size);
header->max_stack = max_stack;
header->init_locals = rmb->init_locals;
container->type_argc = count;
container->type_params = image_g_new0 (image, MonoGenericParamFull, count);
container->owner.method = m;
+ container->is_anonymous = FALSE; // Method is now known, container is no longer anonymous
m->is_generic = TRUE;
mono_method_set_generic_container (m, container);
if (pb->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT) {
MonoDynamicImage *assembly;
- guint32 idx, def_type, len;
+ guint32 idx, len;
+ MonoTypeEnum def_type;
char *p;
const char *p2;
p = assembly->blob.data + idx;
len = mono_metadata_decode_blob_size (p, &p2);
len += p2 - p;
- method_aux->param_defaults [i] = image_g_malloc (image, len);
+ method_aux->param_defaults [i] = (uint8_t *)image_g_malloc (image, len);
method_aux->param_default_types [i] = def_type;
memcpy ((gpointer)method_aux->param_defaults [i], p, len);
}
type_argv = g_new0 (MonoType *, count);
for (i = 0; i < count; i++) {
- MonoReflectionType *garg = mono_array_get (types, gpointer, i);
+ MonoReflectionType *garg = (MonoReflectionType *)mono_array_get (types, gpointer, i);
type_argv [i] = mono_reflection_type_get_handle (garg);
}
ginst = mono_metadata_get_generic_inst (count, type_argv);
dgclass->field_generic_types = mono_image_set_new0 (gclass->owner, MonoType*, dgclass->count_fields);
for (i = 0; i < dgclass->count_fields; i++) {
- MonoObject *obj = mono_array_get (fields, gpointer, i);
+ MonoObject *obj = (MonoObject *)mono_array_get (fields, gpointer, i);
MonoClassField *field, *inflated_field = NULL;
if (!strcmp (obj->vtable->klass->name, "FieldBuilder"))
if (klass->method.count != gklass->method.count) {
klass->method.count = gklass->method.count;
- klass->methods = mono_image_alloc (klass->image, sizeof (MonoMethod*) * (klass->method.count + 1));
+ klass->methods = (MonoMethod **)mono_image_alloc (klass->image, sizeof (MonoMethod*) * (klass->method.count + 1));
for (i = 0; i < klass->method.count; i++) {
MonoError error;
if (klass->interface_count && klass->interface_count != gklass->interface_count) {
klass->interface_count = gklass->interface_count;
- klass->interfaces = mono_image_alloc (klass->image, sizeof (MonoClass*) * gklass->interface_count);
+ klass->interfaces = (MonoClass **)mono_image_alloc (klass->image, sizeof (MonoClass*) * gklass->interface_count);
klass->interfaces_packed = NULL; /*make setup_interface_offsets happy*/
for (i = 0; i < gklass->interface_count; ++i) {
static void
ensure_runtime_vtable (MonoClass *klass)
{
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
int i, num, j;
if (!image_is_dynamic (klass->image) || (!tb && !klass->generic_class) || klass->wastypebuilder)
num = tb->ctors? mono_array_length (tb->ctors): 0;
num += tb->num_methods;
klass->method.count = num;
- klass->methods = mono_image_alloc (klass->image, sizeof (MonoMethod*) * num);
+ klass->methods = (MonoMethod **)mono_image_alloc (klass->image, sizeof (MonoMethod*) * num);
num = tb->ctors? mono_array_length (tb->ctors): 0;
for (i = 0; i < num; ++i)
klass->methods [i] = ctorbuilder_to_mono_method (klass, mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i));
if (tb->interfaces) {
klass->interface_count = mono_array_length (tb->interfaces);
- klass->interfaces = mono_image_alloc (klass->image, sizeof (MonoClass*) * klass->interface_count);
+ klass->interfaces = (MonoClass **)mono_image_alloc (klass->image, sizeof (MonoClass*) * klass->interface_count);
for (i = 0; i < klass->interface_count; ++i) {
MonoType *iface = mono_type_array_get_and_resolve (tb->interfaces, i);
klass->interfaces [i] = mono_class_from_mono_type (iface);
static MonoMethod*
mono_reflection_method_get_handle (MonoObject *method)
{
- MonoClass *class = mono_object_class (method);
- if (is_sr_mono_method (class) || is_sr_mono_generic_method (class)) {
+ MonoClass *klass = mono_object_class (method);
+ if (is_sr_mono_method (klass) || is_sr_mono_generic_method (klass)) {
MonoReflectionMethod *sr_method = (MonoReflectionMethod*)method;
return sr_method->method;
}
- if (is_sre_method_builder (class)) {
+ if (is_sre_method_builder (klass)) {
MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder*)method;
return mb->mhandle;
}
- if (is_sre_method_on_tb_inst (class)) {
+ if (is_sre_method_on_tb_inst (klass)) {
MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)method;
MonoMethod *result;
/*FIXME move this to a proper method and unify with resolve_object*/
return result;
}
- g_error ("Can't handle methods of type %s:%s", class->name_space, class->name);
+ g_error ("Can't handle methods of type %s:%s", klass->name_space, klass->name);
return NULL;
}
static void
typebuilder_setup_fields (MonoClass *klass, MonoError *error)
{
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
MonoReflectionFieldBuilder *fb;
MonoClassField *field;
MonoImage *image = klass->image;
for (i = 0; i < klass->field.count; ++i) {
MonoArray *rva_data;
- fb = mono_array_get (tb->fields, gpointer, i);
+ fb = (MonoReflectionFieldBuilder *)mono_array_get (tb->fields, gpointer, i);
field = &klass->fields [i];
field->name = mono_string_to_utf8_image (image, fb->name, error);
if (!mono_error_ok (error))
if ((fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) && (rva_data = fb->rva_data)) {
char *base = mono_array_addr (rva_data, char, 0);
size_t size = mono_array_length (rva_data);
- char *data = mono_image_alloc (klass->image, size);
+ char *data = (char *)mono_image_alloc (klass->image, size);
memcpy (data, base, size);
klass->ext->field_def_values [i].data = data;
}
p = assembly->blob.data + idx;
len = mono_metadata_decode_blob_size (p, &p2);
len += p2 - p;
- klass->ext->field_def_values [i].data = mono_image_alloc (image, len);
+ klass->ext->field_def_values [i].data = (const char *)mono_image_alloc (image, len);
memcpy ((gpointer)klass->ext->field_def_values [i].data, p, len);
}
}
static void
typebuilder_setup_properties (MonoClass *klass, MonoError *error)
{
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
MonoReflectionPropertyBuilder *pb;
MonoImage *image = klass->image;
MonoProperty *properties;
p = assembly->blob.data + idx;
len = mono_metadata_decode_blob_size (p, &p2);
len += p2 - p;
- klass->ext->prop_def_values [i].data = mono_image_alloc (image, len);
+ klass->ext->prop_def_values [i].data = (const char *)mono_image_alloc (image, len);
memcpy ((gpointer)klass->ext->prop_def_values [i].data, p, len);
}
}
static void
typebuilder_setup_events (MonoClass *klass, MonoError *error)
{
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
MonoReflectionEventBuilder *eb;
MonoImage *image = klass->image;
MonoEvent *events;
check_array_for_usertypes (tb->interfaces);
if (tb->fields) {
for (i = 0; i < mono_array_length (tb->fields); ++i) {
- MonoReflectionFieldBuilder *fb = mono_array_get (tb->fields, gpointer, i);
+ MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)mono_array_get (tb->fields, gpointer, i);
if (fb) {
RESOLVE_TYPE (fb->type);
check_array_for_usertypes (fb->modreq);
}
if (tb->methods) {
for (i = 0; i < mono_array_length (tb->methods); ++i) {
- MonoReflectionMethodBuilder *mb = mono_array_get (tb->methods, gpointer, i);
+ MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)mono_array_get (tb->methods, gpointer, i);
if (mb) {
RESOLVE_TYPE (mb->rtype);
check_array_for_usertypes (mb->return_modreq);
}
if (tb->ctors) {
for (i = 0; i < mono_array_length (tb->ctors); ++i) {
- MonoReflectionCtorBuilder *mb = mono_array_get (tb->ctors, gpointer, i);
+ MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)mono_array_get (tb->ctors, gpointer, i);
if (mb) {
check_array_for_usertypes (mb->parameters);
if (mb->param_modreq)
if (!gparam->mbuilder->generic_container) {
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)gparam->mbuilder->type;
MonoClass *klass = mono_class_from_mono_type (mono_reflection_type_get_handle ((MonoReflectionType*)tb));
- gparam->mbuilder->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
+ gparam->mbuilder->generic_container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
gparam->mbuilder->generic_container->is_method = TRUE;
/*
* Cannot set owner.method, since the MonoMethod is not created yet.
* Set the image field instead, so type_in_image () works.
*/
- gparam->mbuilder->generic_container->image = klass->image;
+ gparam->mbuilder->generic_container->is_anonymous = TRUE;
+ gparam->mbuilder->generic_container->owner.image = klass->image;
}
param->param.owner = gparam->mbuilder->generic_container;
} else if (gparam->tbuilder) {
if (!gparam->tbuilder->generic_container) {
MonoClass *klass = mono_class_from_mono_type (mono_reflection_type_get_handle ((MonoReflectionType*)gparam->tbuilder));
- gparam->tbuilder->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
+ gparam->tbuilder->generic_container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
gparam->tbuilder->generic_container->owner.klass = klass;
}
param->param.owner = gparam->tbuilder->generic_container;
}
- pklass = mono_class_from_generic_parameter ((MonoGenericParam *) param, image, gparam->mbuilder != NULL);
+ pklass = mono_class_from_generic_parameter_internal ((MonoGenericParam *) param);
gparam->type.type = &pklass->byval_arg;
static void
free_dynamic_method (void *dynamic_method)
{
- DynamicMethodReleaseData *data = dynamic_method;
+ DynamicMethodReleaseData *data = (DynamicMethodReleaseData *)dynamic_method;
MonoDomain *domain = data->domain;
MonoMethod *method = data->handle;
guint32 dis_link;
mono_error_init (error);
- sig = g_hash_table_lookup (((MonoDynamicImage*)image)->vararg_aux_hash, GUINT_TO_POINTER (token));
+ sig = (MonoMethodSignature *)g_hash_table_lookup (((MonoDynamicImage*)image)->vararg_aux_hash, GUINT_TO_POINTER (token));
if (sig)
return sig;
ensure_complete_type (MonoClass *klass)
{
if (image_is_dynamic (klass->image) && !klass->wastypebuilder && mono_class_get_ref_info (klass)) {
- MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
result = ((MonoReflectionMethod*)obj)->method;
if (context) {
MonoError error;
- result = mono_class_inflate_generic_method_checked (result, context, &error);
+ result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, &error);
g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
}
*handle_class = mono_defaults.methodhandle_class;
}
if (context) {
MonoError error;
- result = mono_class_inflate_generic_method_checked (result, context, &error);
+ result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, &error);
g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
}
*handle_class = mono_defaults.methodhandle_class;
}
if (context) {
MonoError error;
- result = mono_class_inflate_generic_method_checked (result, context, &error);
+ result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, &error);
g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
}
*handle_class = mono_defaults.methodhandle_class;
ensure_complete_type (field->parent);
if (context) {
MonoType *inflated = mono_class_inflate_generic_type (&field->parent->byval_arg, context);
- MonoClass *class = mono_class_from_mono_type (inflated);
+ MonoClass *klass = mono_class_from_mono_type (inflated);
MonoClassField *inflated_field;
gpointer iter = NULL;
mono_metadata_free_type (inflated);
- while ((inflated_field = mono_class_get_fields (class, &iter))) {
+ while ((inflated_field = mono_class_get_fields (klass, &iter))) {
if (!strcmp (field->name, inflated_field->name))
break;
}
result = mono_reflection_method_on_tb_inst_get_handle (m);
if (context) {
MonoError error;
- result = mono_class_inflate_generic_method_checked (result, context, &error);
+ result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, &error);
g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
}
} else {
projects / mono.git / blobdiff