X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fclass.c;h=3cfda363e3cce5d6dc557541346aa0e5071e5d67;hb=20a111a215c2ad93ab77068d2e81e21c886b9846;hp=fdfd5c31505f0ffb427a0655627bf562f558ca27;hpb=28f473c41df72b278eaf9784c29c2b8fa2cbe06a;p=mono.git diff --git a/mono/metadata/class.c b/mono/metadata/class.c index fdfd5c31505..3cfda363e3c 100644 --- a/mono/metadata/class.c +++ b/mono/metadata/class.c @@ -33,16 +33,17 @@ #include #include #include -#include +#include #include #include #include #include #include -#include +#include #include #include #include +#include MonoStats mono_stats; @@ -63,14 +64,14 @@ static MonoClass * mono_class_create_from_typedef (MonoImage *image, guint32 typ static gboolean mono_class_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res); static gboolean can_access_type (MonoClass *access_klass, MonoClass *member_klass); static MonoMethod* find_method_in_metadata (MonoClass *klass, const char *name, int param_count, int flags); -static int generic_array_methods (MonoClass *class); -static void setup_generic_array_ifaces (MonoClass *class, MonoClass *iface, MonoMethod **methods, int pos); +static int generic_array_methods (MonoClass *klass); +static void setup_generic_array_ifaces (MonoClass *klass, MonoClass *iface, MonoMethod **methods, int pos); static MonoMethod* mono_class_get_virtual_methods (MonoClass* klass, gpointer *iter); static char* mono_assembly_name_from_token (MonoImage *image, guint32 type_token); static void mono_field_resolve_type (MonoClassField *field, MonoError *error); static guint32 mono_field_resolve_flags (MonoClassField *field); -static void mono_class_setup_vtable_full (MonoClass *class, GList *in_setup); +static void mono_class_setup_vtable_full (MonoClass *klass, GList *in_setup); static void mono_generic_class_setup_parent (MonoClass *klass, MonoClass *gklass); /* @@ -103,13 +104,13 @@ typedef gboolean (*gclass_record_func) (MonoClass*, void*); static inline void classes_lock (void) { - mono_locks_acquire (&classes_mutex, ClassesLock); + mono_locks_os_acquire (&classes_mutex, ClassesLock); } static inline void classes_unlock (void) { - mono_locks_release (&classes_mutex, ClassesLock); + mono_locks_os_release (&classes_mutex, ClassesLock); } /* @@ -149,25 +150,38 @@ disable_gclass_recording (gclass_record_func func, void *user_data) } } -/* +/** * mono_class_from_typeref: * @image: a MonoImage * @type_token: a TypeRef token * * Creates the MonoClass* structure representing the type defined by * the typeref token valid inside @image. - * Returns: the MonoClass* representing the typeref token, NULL ifcould + * Returns: The MonoClass* representing the typeref token, NULL ifcould * not be loaded. */ MonoClass * mono_class_from_typeref (MonoImage *image, guint32 type_token) { MonoError error; - MonoClass *class = mono_class_from_typeref_checked (image, type_token, &error); + MonoClass *klass = mono_class_from_typeref_checked (image, type_token, &error); g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/ - return class; + return klass; } +/** + * mono_class_from_typeref_checked: + * @image: a MonoImage + * @type_token: a TypeRef token + * @error: error return code, if any. + * + * Creates the MonoClass* structure representing the type defined by + * the typeref token valid inside @image. + * + * Returns: The MonoClass* representing the typeref token, NULL if it could + * not be loaded with the @error value filled with the information about the + * error. + */ MonoClass * mono_class_from_typeref_checked (MonoImage *image, guint32 type_token, MonoError *error) { @@ -216,13 +230,12 @@ mono_class_from_typeref_checked (MonoImage *image, guint32 type_token, MonoError } enclosing = mono_class_from_typeref_checked (image, MONO_TOKEN_TYPE_REF | idx, error); - if (!mono_error_ok (error)) - return NULL; + return_val_if_nok (error, NULL); if (enclosing->nested_classes_inited && enclosing->ext) { /* Micro-optimization: don't scan the metadata tables if enclosing is already inited */ for (tmp = enclosing->ext->nested_classes; tmp; tmp = tmp->next) { - res = tmp->data; + res = (MonoClass *)tmp->data; if (strcmp (res->name, name) == 0) return res; } @@ -298,17 +311,17 @@ MonoArrayType * mono_dup_array_type (MonoImage *image, MonoArrayType *a) { if (image) { - a = mono_image_memdup (image, a, sizeof (MonoArrayType)); + a = (MonoArrayType *)mono_image_memdup (image, a, sizeof (MonoArrayType)); if (a->sizes) - a->sizes = mono_image_memdup (image, a->sizes, a->numsizes * sizeof (int)); + a->sizes = (int *)mono_image_memdup (image, a->sizes, a->numsizes * sizeof (int)); if (a->lobounds) - a->lobounds = mono_image_memdup (image, a->lobounds, a->numlobounds * sizeof (int)); + a->lobounds = (int *)mono_image_memdup (image, a->lobounds, a->numlobounds * sizeof (int)); } else { - a = g_memdup (a, sizeof (MonoArrayType)); + a = (MonoArrayType *)g_memdup (a, sizeof (MonoArrayType)); if (a->sizes) - a->sizes = g_memdup (a->sizes, a->numsizes * sizeof (int)); + a->sizes = (int *)g_memdup (a->sizes, a->numsizes * sizeof (int)); if (a->lobounds) - a->lobounds = g_memdup (a->lobounds, a->numlobounds * sizeof (int)); + a->lobounds = (int *)g_memdup (a->lobounds, a->numlobounds * sizeof (int)); } return a; } @@ -346,6 +359,50 @@ mono_type_name_check_byref (MonoType *type, GString *str) g_string_append_c (str, '&'); } +/** + * mono_identifier_escape_type_name_chars: + * @str: a destination string + * @identifier: an IDENTIFIER in internal form + * + * Returns: str. + * + * The displayed form of the identifier is appended to str. + * + * The displayed form of an identifier has the characters ,+&*[]\ + * that have special meaning in type names escaped with a preceeding + * backslash (\) character. + */ +static GString* +mono_identifier_escape_type_name_chars (GString* str, const char* identifier) +{ + if (!identifier) + return str; + + size_t n = str->len; + // reserve space for common case: there will be no escaped characters. + g_string_set_size(str, n + strlen(identifier)); + g_string_set_size(str, n); + + for (const char* s = identifier; *s != 0 ; s++) { + switch (*s) { + case ',': + case '+': + case '&': + case '*': + case '[': + case ']': + case '\\': + g_string_append_c (str, '\\'); + g_string_append_c (str, *s); + break; + default: + g_string_append_c (str, *s); + break; + } + } + return str; +} + static void mono_type_get_name_recurse (MonoType *type, GString *str, gboolean is_recursed, MonoTypeNameFormat format) @@ -427,16 +484,19 @@ mono_type_get_name_recurse (MonoType *type, GString *str, gboolean is_recursed, else g_string_append_c (str, '+'); } else if (*klass->name_space) { - g_string_append (str, klass->name_space); + if (format == MONO_TYPE_NAME_FORMAT_IL) + g_string_append (str, klass->name_space); + else + mono_identifier_escape_type_name_chars (str, klass->name_space); g_string_append_c (str, '.'); } if (format == MONO_TYPE_NAME_FORMAT_IL) { char *s = strchr (klass->name, '`'); int len = s ? s - klass->name : strlen (klass->name); - g_string_append_len (str, klass->name, len); - } else - g_string_append (str, klass->name); + } else { + mono_identifier_escape_type_name_chars (str, klass->name); + } if (is_recursed) break; if (klass->generic_class) { @@ -504,7 +564,7 @@ mono_type_get_name_recurse (MonoType *type, GString *str, gboolean is_recursed, * @format: the format for the return string. * * - * Returns: the string representation in a number of formats: + * Returns: The string representation in a number of formats: * * if format is MONO_TYPE_NAME_FORMAT_REFLECTION, the return string is * returned in the formatrequired by System.Reflection, this is the @@ -533,20 +593,20 @@ mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format) * mono_type_get_full_name: * @class: a class * - * Returns: the string representation for type as required by System.Reflection. + * Returns: The string representation for type as required by System.Reflection. * The inverse of mono_reflection_parse_type (). */ char * -mono_type_get_full_name (MonoClass *class) +mono_type_get_full_name (MonoClass *klass) { - return mono_type_get_name_full (mono_class_get_type (class), MONO_TYPE_NAME_FORMAT_REFLECTION); + return mono_type_get_name_full (mono_class_get_type (klass), MONO_TYPE_NAME_FORMAT_REFLECTION); } /** * mono_type_get_name: * @type: a type * - * Returns: the string representation for type as it would be represented in IL code. + * Returns: The string representation for type as it would be represented in IL code. */ char* mono_type_get_name (MonoType *type) @@ -558,7 +618,7 @@ mono_type_get_name (MonoType *type) * mono_type_get_underlying_type: * @type: a type * - * Returns: the MonoType for the underlying integer type if @type + * Returns: The MonoType for the underlying integer type if @type * is an enum and byref is false, otherwise the type itself. */ MonoType* @@ -571,11 +631,11 @@ mono_type_get_underlying_type (MonoType *type) return type; } -/* +/** * mono_class_is_open_constructed_type: * @type: a type * - * Returns TRUE if type represents a generics open constructed type. + * Returns: TRUE if type represents a generics open constructed type. * IOW, not all type parameters required for the instantiation have * been provided or it's a generic type definition. * @@ -708,8 +768,8 @@ inflate_generic_type (MonoImage *image, MonoType *type, MonoGenericContext *cont return NULL; inst = mono_metadata_inflate_generic_inst (gclass->context.class_inst, context, error); - if (!mono_error_ok (error)) - return NULL; + return_val_if_nok (error, NULL); + if (inst != gclass->context.class_inst) gclass = mono_metadata_lookup_generic_class (gclass->container_class, inst, gclass->is_dynamic); @@ -733,8 +793,8 @@ inflate_generic_type (MonoImage *image, MonoType *type, MonoGenericContext *cont /* We can't use context->class_inst directly, since it can have more elements */ inst = mono_metadata_inflate_generic_inst (container->context.class_inst, context, error); - if (!mono_error_ok (error)) - return NULL; + return_val_if_nok (error, NULL); + if (inst == container->context.class_inst) return NULL; @@ -758,9 +818,9 @@ mono_generic_class_get_context (MonoGenericClass *gclass) } MonoGenericContext * -mono_class_get_context (MonoClass *class) +mono_class_get_context (MonoClass *klass) { - return class->generic_class ? mono_generic_class_get_context (class->generic_class) : NULL; + return klass->generic_class ? mono_generic_class_get_context (klass->generic_class) : NULL; } /* @@ -810,8 +870,7 @@ mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, if (context) inflated = inflate_generic_type (image, type, context, error); - if (!mono_error_ok (error)) - return NULL; + return_val_if_nok (error, NULL); if (!inflated) { MonoType *shared = mono_metadata_get_shared_type (type); @@ -835,7 +894,7 @@ mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, * If @type is a generic type and @context is not NULL, instantiate it using the * generics context @context. * - * Returns: the instantiated type or a copy of @type. The returned MonoType is allocated + * Returns: The instantiated type or a copy of @type. The returned MonoType is allocated * on the heap and is owned by the caller. Returns NULL on error. * * @deprecated Please use mono_class_inflate_generic_type_checked instead @@ -846,11 +905,7 @@ mono_class_inflate_generic_type (MonoType *type, MonoGenericContext *context) MonoError error; MonoType *result; result = mono_class_inflate_generic_type_checked (type, context, &error); - - if (!mono_error_ok (&error)) { - mono_error_cleanup (&error); - return NULL; - } + mono_error_cleanup (&error); return result; } @@ -863,7 +918,7 @@ mono_class_inflate_generic_type (MonoType *type, MonoGenericContext *context) * If @type is a generic type and @context is not NULL, instantiate it using the * generics context @context. * - * Returns: the instantiated type or a copy of @type. The returned MonoType is allocated + * Returns: The instantiated type or a copy of @type. The returned MonoType is allocated * on the heap and is owned by the caller. */ MonoType* @@ -886,8 +941,7 @@ mono_class_inflate_generic_type_no_copy (MonoImage *image, MonoType *type, MonoG mono_error_init (error); if (context) { inflated = inflate_generic_type (image, type, context, error); - if (!mono_error_ok (error)) - return NULL; + return_val_if_nok (error, NULL); } if (!inflated) @@ -897,6 +951,11 @@ mono_class_inflate_generic_type_no_copy (MonoImage *image, MonoType *type, MonoG return inflated; } +/* + * mono_class_inflate_generic_class: + * + * Inflate the class @gklass with @context. Set @error on failure. + */ MonoClass* mono_class_inflate_generic_class_checked (MonoClass *gklass, MonoGenericContext *context, MonoError *error) { @@ -904,32 +963,13 @@ mono_class_inflate_generic_class_checked (MonoClass *gklass, MonoGenericContext MonoType *inflated; inflated = mono_class_inflate_generic_type_checked (&gklass->byval_arg, context, error); - if (!mono_error_ok (error)) - return NULL; + return_val_if_nok (error, NULL); res = mono_class_from_mono_type (inflated); mono_metadata_free_type (inflated); return res; } -/* - * mono_class_inflate_generic_class: - * - * Inflate the class GKLASS with CONTEXT. - */ -MonoClass* -mono_class_inflate_generic_class (MonoClass *gklass, MonoGenericContext *context) -{ - MonoError error; - MonoClass *res; - - res = mono_class_inflate_generic_class_checked (gklass, context, &error); - g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/ - - return res; -} - - static MonoGenericContext inflate_generic_context (MonoGenericContext *context, MonoGenericContext *inflate_with, MonoError *error) @@ -965,7 +1005,7 @@ fail: * * Instantiate the generic method @method using the generics context @context. * - * Returns: the new instantiated method + * Returns: The new instantiated method */ MonoMethod * mono_class_inflate_generic_method (MonoMethod *method, MonoGenericContext *context) @@ -1018,8 +1058,8 @@ mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *k MonoMethodInflated *imethod = (MonoMethodInflated *) method; tmp_context = inflate_generic_context (method_context, context, error); - if (!mono_error_ok (error)) - return NULL; + return_val_if_nok (error, NULL); + context = &tmp_context; if (mono_metadata_generic_context_equal (method_context, context)) @@ -1062,7 +1102,7 @@ mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *k // check cache mono_image_set_lock (set); - cached = g_hash_table_lookup (set->gmethod_cache, iresult); + cached = (MonoMethodInflated *)g_hash_table_lookup (set->gmethod_cache, iresult); mono_image_set_unlock (set); if (cached) { @@ -1137,7 +1177,7 @@ mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *k // check cache mono_image_set_lock (set); - cached = g_hash_table_lookup (set->gmethod_cache, iresult); + cached = (MonoMethodInflated *)g_hash_table_lookup (set->gmethod_cache, iresult); if (!cached) { g_hash_table_insert (set->gmethod_cache, iresult, iresult); iresult->owner = set; @@ -1217,7 +1257,7 @@ mono_method_get_generic_container (MonoMethod *method) if (!method->is_generic) return NULL; - container = mono_image_property_lookup (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER); + container = (MonoGenericContainer *)mono_image_property_lookup (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER); g_assert (container); return container; @@ -1245,21 +1285,21 @@ mono_method_set_generic_container (MonoMethod *method, MonoGenericContainer* con * in a separate function since it is cheaper than calling mono_class_setup_fields. */ static MonoType* -mono_class_find_enum_basetype (MonoClass *class, MonoError *error) +mono_class_find_enum_basetype (MonoClass *klass, MonoError *error) { MonoGenericContainer *container = NULL; - MonoImage *m = class->image; - const int top = class->field.count; + MonoImage *m = klass->image; + const int top = klass->field.count; int i; - g_assert (class->enumtype); + g_assert (klass->enumtype); mono_error_init (error); - if (class->generic_container) - container = class->generic_container; - else if (class->generic_class) { - MonoClass *gklass = class->generic_class->container_class; + if (klass->generic_container) + container = klass->generic_container; + else if (klass->generic_class) { + MonoClass *gklass = klass->generic_class->container_class; container = gklass->generic_container; g_assert (container); @@ -1271,17 +1311,17 @@ mono_class_find_enum_basetype (MonoClass *class, MonoError *error) for (i = 0; i < top; i++){ const char *sig; guint32 cols [MONO_FIELD_SIZE]; - int idx = class->field.first + i; + int idx = klass->field.first + i; MonoType *ftype; - /* class->field.first and idx points into the fieldptr table */ + /* klass->field.first and idx points into the fieldptr table */ mono_metadata_decode_table_row (m, MONO_TABLE_FIELD, idx, cols, MONO_FIELD_SIZE); if (cols [MONO_FIELD_FLAGS] & FIELD_ATTRIBUTE_STATIC) //no need to decode static fields continue; - if (!mono_verifier_verify_field_signature (class->image, cols [MONO_FIELD_SIGNATURE], NULL)) { - mono_error_set_bad_image (error, class->image, "Invalid field signature %x", cols [MONO_FIELD_SIGNATURE]); + if (!mono_verifier_verify_field_signature (klass->image, cols [MONO_FIELD_SIGNATURE], NULL)) { + mono_error_set_bad_image (error, klass->image, "Invalid field signature %x", cols [MONO_FIELD_SIGNATURE]); goto fail; } @@ -1289,21 +1329,17 @@ mono_class_find_enum_basetype (MonoClass *class, MonoError *error) mono_metadata_decode_value (sig, &sig); /* FIELD signature == 0x06 */ if (*sig != 0x06) { - mono_error_set_bad_image (error, class->image, "Invalid field signature %x, expected 0x6 but got %x", cols [MONO_FIELD_SIGNATURE], *sig); + mono_error_set_bad_image (error, klass->image, "Invalid field signature %x, expected 0x6 but got %x", cols [MONO_FIELD_SIGNATURE], *sig); goto fail; } - ftype = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig); - if (!ftype) { - if (mono_loader_get_last_error ()) /*FIXME plug the above to not leak errors*/ - mono_error_set_from_loader_error (error); - else - mono_error_set_bad_image (error, class->image, "Could not parse type for field signature %x", cols [MONO_FIELD_SIGNATURE]); + ftype = mono_metadata_parse_type_checked (m, container, cols [MONO_FIELD_FLAGS], FALSE, sig + 1, &sig, error); + if (!ftype) goto fail; - } - if (class->generic_class) { + + if (klass->generic_class) { //FIXME do we leak here? - ftype = mono_class_inflate_generic_type_checked (ftype, mono_class_get_context (class), error); + ftype = mono_class_inflate_generic_type_checked (ftype, mono_class_get_context (klass), error); if (!mono_error_ok (error)) goto fail; ftype->attrs = cols [MONO_FIELD_FLAGS]; @@ -1311,7 +1347,7 @@ mono_class_find_enum_basetype (MonoClass *class, MonoError *error) return ftype; } - mono_error_set_type_load_class (error, class, "Could not find base type"); + mono_error_set_type_load_class (error, klass, "Could not find base type"); fail: mono_loader_assert_no_error (); @@ -1328,11 +1364,11 @@ mono_type_has_exceptions (MonoType *type) case MONO_TYPE_CLASS: case MONO_TYPE_VALUETYPE: case MONO_TYPE_SZARRAY: - return type->data.klass->exception_type; + return mono_class_has_failure (type->data.klass); case MONO_TYPE_ARRAY: - return type->data.array->eklass->exception_type; + return mono_class_has_failure (type->data.array->eklass); case MONO_TYPE_GENERICINST: - return mono_generic_class_get_class (type->data.generic_class)->exception_type; + return mono_class_has_failure (mono_generic_class_get_class (type->data.generic_class)); default: return FALSE; } @@ -1345,50 +1381,50 @@ mono_type_has_exceptions (MonoType *type) * or from the heap. */ static gpointer -mono_class_alloc (MonoClass *class, int size) +mono_class_alloc (MonoClass *klass, int size) { - if (class->generic_class) - return mono_image_set_alloc (class->generic_class->owner, size); + if (klass->generic_class) + return mono_image_set_alloc (klass->generic_class->owner, size); else - return mono_image_alloc (class->image, size); + return mono_image_alloc (klass->image, size); } static gpointer -mono_class_alloc0 (MonoClass *class, int size) +mono_class_alloc0 (MonoClass *klass, int size) { gpointer res; - res = mono_class_alloc (class, size); + res = mono_class_alloc (klass, size); memset (res, 0, size); return res; } -#define mono_class_new0(class,struct_type, n_structs) \ - ((struct_type *) mono_class_alloc0 ((class), ((gsize) sizeof (struct_type)) * ((gsize) (n_structs)))) +#define mono_class_new0(klass,struct_type, n_structs) \ + ((struct_type *) mono_class_alloc0 ((klass), ((gsize) sizeof (struct_type)) * ((gsize) (n_structs)))) /** * mono_class_setup_basic_field_info: * @class: The class to initialize * - * Initializes the class->fields. + * Initializes the klass->fields. * LOCKING: Assumes the loader lock is held. */ static void -mono_class_setup_basic_field_info (MonoClass *class) +mono_class_setup_basic_field_info (MonoClass *klass) { MonoClassField *field; MonoClass *gtd; MonoImage *image; int i, top; - if (class->fields) + if (klass->fields) return; - gtd = class->generic_class ? mono_class_get_generic_type_definition (class) : NULL; - image = class->image; - top = class->field.count; + gtd = klass->generic_class ? mono_class_get_generic_type_definition (klass) : NULL; + image = klass->image; + top = klass->field.count; - if (class->generic_class && image_is_dynamic (class->generic_class->container_class->image) && !class->generic_class->container_class->wastypebuilder) { + if (klass->generic_class && image_is_dynamic (klass->generic_class->container_class->image) && !klass->generic_class->container_class->wastypebuilder) { /* * This happens when a generic instance of an unfinished generic typebuilder * is used as an element type for creating an array type. We can't initialize @@ -1402,24 +1438,24 @@ mono_class_setup_basic_field_info (MonoClass *class) mono_class_setup_basic_field_info (gtd); top = gtd->field.count; - class->field.first = gtd->field.first; - class->field.count = gtd->field.count; + klass->field.first = gtd->field.first; + klass->field.count = gtd->field.count; } - class->fields = mono_class_alloc0 (class, sizeof (MonoClassField) * top); + klass->fields = (MonoClassField *)mono_class_alloc0 (klass, sizeof (MonoClassField) * top); /* * Fetch all the field information. */ for (i = 0; i < top; i++){ - field = &class->fields [i]; - field->parent = class; + field = &klass->fields [i]; + field->parent = klass; if (gtd) { field->name = mono_field_get_name (>d->fields [i]); } else { - int idx = class->field.first + i; - /* class->field.first and idx points into the fieldptr table */ + int idx = klass->field.first + i; + /* klass->field.first and idx points into the fieldptr table */ guint32 name_idx = mono_metadata_decode_table_row_col (image, MONO_TABLE_FIELD, idx, MONO_FIELD_NAME); /* The name is needed for fieldrefs */ field->name = mono_metadata_string_heap (image, name_idx); @@ -1431,23 +1467,23 @@ mono_class_setup_basic_field_info (MonoClass *class) * mono_class_setup_fields: * @class: The class to initialize * - * Initializes the class->fields. + * Initializes the klass->fields. * LOCKING: Assumes the loader lock is held. */ static void -mono_class_setup_fields (MonoClass *class) +mono_class_setup_fields (MonoClass *klass) { MonoError error; - MonoImage *m = class->image; + MonoImage *m = klass->image; int top; - guint32 layout = class->flags & TYPE_ATTRIBUTE_LAYOUT_MASK; + guint32 layout = klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK; int i, blittable = TRUE; guint32 real_size = 0; guint32 packing_size = 0; gboolean explicit_size; MonoClassField *field; MonoGenericContainer *container = NULL; - MonoClass *gtd = class->generic_class ? mono_class_get_generic_type_definition (class) : NULL; + MonoClass *gtd = klass->generic_class ? mono_class_get_generic_type_definition (klass) : NULL; /* * FIXME: We have a race condition here. It's possible that this function returns @@ -1462,14 +1498,14 @@ mono_class_setup_fields (MonoClass *class) * This function is called for a class whenever one of its subclasses is inited. * For example, it's called for every subclass of Object. What it does is this: * - * if (class->setup_fields_called) + * if (klass->setup_fields_called) * return; * ... - * class->instance_size = 0; + * klass->instance_size = 0; * ... - * class->setup_fields_called = 1; + * klass->setup_fields_called = 1; * ... critical point - * class->instance_size = actual_instance_size; + * klass->instance_size = actual_instance_size; * * The last two steps are sometimes reversed, but that only changes the way in which * the race condition works. @@ -1480,14 +1516,14 @@ mono_class_setup_fields (MonoClass *class) * * The other case looks like this: * - * if (class->setup_fields_called) + * if (klass->setup_fields_called) * return; * ... critical point X - * class->instance_size = 0; + * klass->instance_size = 0; * ... critical point Y - * class->instance_size = actual_instance_size; + * klass->instance_size = actual_instance_size; * ... - * class->setup_fields_called = 1; + * klass->setup_fields_called = 1; * * Assume thread A goes through the function and makes it to critical point X. Now * thread B runs through the whole of the function, returning, assuming @@ -1495,10 +1531,10 @@ mono_class_setup_fields (MonoClass *class) * critical point Y, at which time `instance_size` is `0` again, invalidating thread * B's assumption. */ - if (class->setup_fields_called) + if (klass->setup_fields_called) return; - if (class->generic_class && image_is_dynamic (class->generic_class->container_class->image) && !class->generic_class->container_class->wastypebuilder) { + if (klass->generic_class && image_is_dynamic (klass->generic_class->container_class->image) && !klass->generic_class->container_class->wastypebuilder) { /* * This happens when a generic instance of an unfinished generic typebuilder * is used as an element type for creating an array type. We can't initialize @@ -1508,39 +1544,39 @@ mono_class_setup_fields (MonoClass *class) return; } - mono_class_setup_basic_field_info (class); - top = class->field.count; + mono_class_setup_basic_field_info (klass); + top = klass->field.count; if (gtd) { mono_class_setup_fields (gtd); - if (gtd->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + if (mono_class_has_failure (gtd)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); return; } } - class->instance_size = 0; - if (!class->rank) - class->sizes.class_size = 0; + klass->instance_size = 0; + if (!klass->rank) + klass->sizes.class_size = 0; - if (class->parent) { - /* For generic instances, class->parent might not have been initialized */ - mono_class_init (class->parent); - if (!class->parent->size_inited) { - mono_class_setup_fields (class->parent); - if (class->parent->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + if (klass->parent) { + /* For generic instances, klass->parent might not have been initialized */ + mono_class_init (klass->parent); + if (!klass->parent->size_inited) { + mono_class_setup_fields (klass->parent); + if (mono_class_has_failure (klass->parent)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); return; } } - class->instance_size += class->parent->instance_size; - class->min_align = class->parent->min_align; + klass->instance_size += klass->parent->instance_size; + klass->min_align = klass->parent->min_align; /* we use |= since it may have been set already */ - class->has_references |= class->parent->has_references; - blittable = class->parent->blittable; + klass->has_references |= klass->parent->has_references; + blittable = klass->parent->blittable; } else { - class->instance_size = sizeof (MonoObject); - class->min_align = 1; + klass->instance_size = sizeof (MonoObject); + klass->min_align = 1; } /* We can't really enable 16 bytes alignment until the GC supports it. @@ -1548,42 +1584,42 @@ mono_class_setup_fields (MonoClass *class) boxed instance, which leads to unexplainable holes at the beginning of an object embedding a simd type. Bug #506144 is an example of this issue. - if (class->simd_type) - class->min_align = 16; + if (klass->simd_type) + klass->min_align = 16; */ /* Get the real size */ - explicit_size = mono_metadata_packing_from_typedef (class->image, class->type_token, &packing_size, &real_size); + explicit_size = mono_metadata_packing_from_typedef (klass->image, klass->type_token, &packing_size, &real_size); if (explicit_size) { if ((packing_size & 0xffffff00) != 0) { - char *err_msg = g_strdup_printf ("Could not load struct '%s' with packing size %d >= 256", class->name, packing_size); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, err_msg); + char *err_msg = g_strdup_printf ("Could not load struct '%s' with packing size %d >= 256", klass->name, packing_size); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg); return; } - class->packing_size = packing_size; - real_size += class->instance_size; + klass->packing_size = packing_size; + real_size += klass->instance_size; } if (!top) { if (explicit_size && real_size) { - class->instance_size = MAX (real_size, class->instance_size); + klass->instance_size = MAX (real_size, klass->instance_size); } - class->blittable = blittable; + klass->blittable = blittable; mono_memory_barrier (); - class->size_inited = 1; - class->fields_inited = 1; - class->setup_fields_called = 1; + klass->size_inited = 1; + klass->fields_inited = 1; + klass->setup_fields_called = 1; return; } - if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT && !(mono_is_corlib_image (class->image) && !strcmp (class->name_space, "System") && !strcmp (class->name, "ValueType"))) + if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT && !(mono_is_corlib_image (klass->image) && !strcmp (klass->name_space, "System") && !strcmp (klass->name, "ValueType"))) blittable = FALSE; /* Prevent infinite loops if the class references itself */ - class->setup_fields_called = 1; + klass->setup_fields_called = 1; - if (class->generic_container) { - container = class->generic_container; + if (klass->generic_container) { + container = klass->generic_container; } else if (gtd) { container = gtd->generic_container; g_assert (container); @@ -1593,10 +1629,10 @@ mono_class_setup_fields (MonoClass *class) * Fetch all the field information. */ for (i = 0; i < top; i++){ - int idx = class->field.first + i; - field = &class->fields [i]; + int idx = klass->field.first + i; + field = &klass->fields [i]; - field->parent = class; + field->parent = klass; if (!field->type) { mono_field_resolve_type (field, &error); @@ -1606,7 +1642,7 @@ mono_class_setup_fields (MonoClass *class) return; } if (!field->type) - g_error ("could not resolve %s:%s\n", mono_type_get_full_name(class), field->name); + g_error ("could not resolve %s:%s\n", mono_type_get_full_name(klass), field->name); g_assert (field->type); } @@ -1622,15 +1658,15 @@ mono_class_setup_fields (MonoClass *class) field->offset = offset; if (field->offset == (guint32)-1 && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Missing field layout info for %s", field->name)); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Missing field layout info for %s", field->name)); break; } if (field->offset < -1) { /*-1 is used to encode special static fields */ - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Invalid negative field offset %d for %s", field->offset, field->name)); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Invalid negative field offset %d for %s", field->offset, field->name)); break; } - if (class->generic_container) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Generic class cannot have explicit layout.")); + if (klass->generic_container) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Generic class cannot have explicit layout.")); break; } } @@ -1644,8 +1680,8 @@ mono_class_setup_fields (MonoClass *class) MonoClass *field_class = mono_class_from_mono_type (field->type); if (field_class) { mono_class_setup_fields (field_class); - if (field_class->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + if (mono_class_has_failure (field_class)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); break; } } @@ -1654,16 +1690,16 @@ mono_class_setup_fields (MonoClass *class) } } - if (class->enumtype && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) { - class->cast_class = class->element_class = mono_class_from_mono_type (field->type); - blittable = class->element_class->blittable; + if (klass->enumtype && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) { + klass->cast_class = klass->element_class = mono_class_from_mono_type (field->type); + blittable = klass->element_class->blittable; } if (mono_type_has_exceptions (field->type)) { - char *class_name = mono_type_get_full_name (class); + char *class_name = mono_type_get_full_name (klass); char *type_name = mono_type_full_name (field->type); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); g_warning ("Invalid type %s for instance field %s:%s", type_name, class_name, field->name); g_free (class_name); g_free (type_name); @@ -1672,46 +1708,46 @@ mono_class_setup_fields (MonoClass *class) /* The def_value of fields is compute lazily during vtable creation */ } - if (class == mono_defaults.string_class) + if (klass == mono_defaults.string_class) blittable = FALSE; - class->blittable = blittable; + klass->blittable = blittable; - if (class->enumtype && !mono_class_enum_basetype (class)) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + if (klass->enumtype && !mono_class_enum_basetype (klass)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); return; } if (explicit_size && real_size) { - class->instance_size = MAX (real_size, class->instance_size); + klass->instance_size = MAX (real_size, klass->instance_size); } - if (class->exception_type) + if (mono_class_has_failure (klass)) return; - mono_class_layout_fields (class); + mono_class_layout_fields (klass); /*valuetypes can't be neither bigger than 1Mb or empty. */ - if (class->valuetype && (class->instance_size <= 0 || class->instance_size > (0x100000 + sizeof (MonoObject)))) - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + if (klass->valuetype && (klass->instance_size <= 0 || klass->instance_size > (0x100000 + sizeof (MonoObject)))) + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); mono_memory_barrier (); - class->fields_inited = 1; + klass->fields_inited = 1; } /** * mono_class_setup_fields_locking: * @class: The class to initialize * - * Initializes the class->fields array of fields. + * Initializes the klass->fields array of fields. * Aquires the loader lock. */ void -mono_class_setup_fields_locking (MonoClass *class) +mono_class_setup_fields_locking (MonoClass *klass) { /* This can be checked without locks */ - if (class->fields_inited) + if (klass->fields_inited) return; mono_loader_lock (); - mono_class_setup_fields (class); + mono_class_setup_fields (klass); mono_loader_unlock (); } @@ -1780,11 +1816,11 @@ type_has_references (MonoClass *klass, MonoType *ftype) * LOCKING: this is supposed to be called with the loader lock held. */ void -mono_class_layout_fields (MonoClass *class) +mono_class_layout_fields (MonoClass *klass) { int i; - const int top = class->field.count; - guint32 layout = class->flags & TYPE_ATTRIBUTE_LAYOUT_MASK; + const int top = klass->field.count; + guint32 layout = klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK; guint32 pass, passes, real_size; gboolean gc_aware_layout = FALSE; gboolean has_static_fields = FALSE; @@ -1808,7 +1844,7 @@ mono_class_layout_fields (MonoClass *class) */ /* corlib is missing [StructLayout] directives in many places */ if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT) { - if (!class->valuetype) + if (!klass->valuetype) gc_aware_layout = TRUE; } @@ -1820,41 +1856,41 @@ mono_class_layout_fields (MonoClass *class) for (i = 0; i < top; i++) { MonoType *ftype; - field = &class->fields [i]; + field = &klass->fields [i]; if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) { ftype = mono_type_get_underlying_type (field->type); ftype = mono_type_get_basic_type_from_generic (ftype); - if (type_has_references (class, ftype)) - class->has_references = TRUE; + if (type_has_references (klass, ftype)) + klass->has_references = TRUE; } } for (i = 0; i < top; i++) { MonoType *ftype; - field = &class->fields [i]; + field = &klass->fields [i]; if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) { ftype = mono_type_get_underlying_type (field->type); ftype = mono_type_get_basic_type_from_generic (ftype); - if (type_has_references (class, ftype)) - class->has_static_refs = TRUE; + if (type_has_references (klass, ftype)) + klass->has_static_refs = TRUE; } } for (i = 0; i < top; i++) { MonoType *ftype; - field = &class->fields [i]; + field = &klass->fields [i]; ftype = mono_type_get_underlying_type (field->type); ftype = mono_type_get_basic_type_from_generic (ftype); - if (type_has_references (class, ftype)) { + if (type_has_references (klass, ftype)) { if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) - class->has_static_refs = TRUE; + klass->has_static_refs = TRUE; else - class->has_references = TRUE; + klass->has_references = TRUE; } } @@ -1874,13 +1910,13 @@ mono_class_layout_fields (MonoClass *class) if (layout != TYPE_ATTRIBUTE_AUTO_LAYOUT) passes = 1; - if (class->parent) { - mono_class_setup_fields (class->parent); - if (class->parent->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + if (klass->parent) { + mono_class_setup_fields (klass->parent); + if (mono_class_has_failure (klass->parent)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); return; } - real_size = class->parent->instance_size; + real_size = klass->parent->instance_size; } else { real_size = sizeof (MonoObject); } @@ -1891,7 +1927,7 @@ mono_class_layout_fields (MonoClass *class) guint32 size; MonoType *ftype; - field = &class->fields [i]; + field = &klass->fields [i]; if (mono_field_is_deleted (field)) continue; @@ -1901,7 +1937,7 @@ mono_class_layout_fields (MonoClass *class) ftype = mono_type_get_underlying_type (field->type); ftype = mono_type_get_basic_type_from_generic (ftype); if (gc_aware_layout) { - if (type_has_references (class, ftype)) { + if (type_has_references (klass, ftype)) { if (pass == 1) continue; } else { @@ -1910,7 +1946,7 @@ mono_class_layout_fields (MonoClass *class) } } - if ((top == 1) && (class->instance_size == sizeof (MonoObject)) && + if ((top == 1) && (klass->instance_size == sizeof (MonoObject)) && (strcmp (mono_field_get_name (field), "$PRIVATE$") == 0)) { /* This field is a hack inserted by MCS to empty structures */ continue; @@ -1919,29 +1955,29 @@ mono_class_layout_fields (MonoClass *class) size = mono_type_size (field->type, &align); /* FIXME (LAMESPEC): should we also change the min alignment according to pack? */ - align = class->packing_size ? MIN (class->packing_size, align): align; + align = klass->packing_size ? MIN (klass->packing_size, align): align; /* if the field has managed references, we need to force-align it * see bug #77788 */ - if (type_has_references (class, ftype)) + if (type_has_references (klass, ftype)) align = MAX (align, sizeof (gpointer)); - class->min_align = MAX (align, class->min_align); + klass->min_align = MAX (align, klass->min_align); field->offset = real_size; if (align) { field->offset += align - 1; field->offset &= ~(align - 1); } /*TypeBuilders produce all sort of weird things*/ - g_assert (image_is_dynamic (class->image) || field->offset > 0); + g_assert (image_is_dynamic (klass->image) || field->offset > 0); real_size = field->offset + size; } - class->instance_size = MAX (real_size, class->instance_size); + klass->instance_size = MAX (real_size, klass->instance_size); - if (class->instance_size & (class->min_align - 1)) { - class->instance_size += class->min_align - 1; - class->instance_size &= ~(class->min_align - 1); + if (klass->instance_size & (klass->min_align - 1)) { + klass->instance_size += klass->min_align - 1; + klass->instance_size &= ~(klass->min_align - 1); } } break; @@ -1954,7 +1990,7 @@ mono_class_layout_fields (MonoClass *class) guint32 size; MonoType *ftype; - field = &class->fields [i]; + field = &klass->fields [i]; /* * There must be info about all the fields in a type if it @@ -1966,8 +2002,8 @@ mono_class_layout_fields (MonoClass *class) continue; size = mono_type_size (field->type, &align); - align = class->packing_size ? MIN (class->packing_size, align): align; - class->min_align = MAX (align, class->min_align); + align = klass->packing_size ? MIN (klass->packing_size, align): align; + klass->min_align = MAX (align, klass->min_align); /* * When we get here, field->offset is already set by the @@ -1978,9 +2014,9 @@ mono_class_layout_fields (MonoClass *class) field->offset += sizeof (MonoObject); ftype = mono_type_get_underlying_type (field->type); ftype = mono_type_get_basic_type_from_generic (ftype); - if (type_has_references (class, ftype)) { + if (type_has_references (klass, ftype)) { if (field->offset % sizeof (gpointer)) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); } } @@ -1990,14 +2026,14 @@ mono_class_layout_fields (MonoClass *class) real_size = MAX (real_size, size + field->offset); } - if (class->has_references) { + if (klass->has_references) { ref_bitmap = g_new0 (guint8, real_size / sizeof (gpointer)); /* Check for overlapping reference and non-reference fields */ for (i = 0; i < top; i++) { MonoType *ftype; - field = &class->fields [i]; + field = &klass->fields [i]; if (mono_field_is_deleted (field)) continue; @@ -2008,7 +2044,7 @@ mono_class_layout_fields (MonoClass *class) ref_bitmap [field->offset / sizeof (gpointer)] = 1; } for (i = 0; i < top; i++) { - field = &class->fields [i]; + field = &klass->fields [i]; if (mono_field_is_deleted (field)) continue; @@ -2018,18 +2054,18 @@ mono_class_layout_fields (MonoClass *class) // FIXME: Too much code does this #if 0 if (!MONO_TYPE_IS_REFERENCE (field->type) && ref_bitmap [field->offset / sizeof (gpointer)]) { - char *err_msg = g_strdup_printf ("Could not load type '%s' because it contains an object field at offset %d that is incorrectly aligned or overlapped by a non-object field.", class->name, field->offset); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, err_msg); + char *err_msg = g_strdup_printf ("Could not load type '%s' because it contains an object field at offset %d that is incorrectly aligned or overlapped by a non-object field.", klass->name, field->offset); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg); } #endif } g_free (ref_bitmap); } - class->instance_size = MAX (real_size, class->instance_size); - if (class->instance_size & (class->min_align - 1)) { - class->instance_size += class->min_align - 1; - class->instance_size &= ~(class->min_align - 1); + klass->instance_size = MAX (real_size, klass->instance_size); + if (klass->instance_size & (klass->min_align - 1)) { + klass->instance_size += klass->min_align - 1; + klass->instance_size &= ~(klass->min_align - 1); } break; } @@ -2045,13 +2081,13 @@ mono_class_layout_fields (MonoClass *class) * unaligned accesses otherwise. See #78990 for a testcase. */ if (mono_align_small_structs) { - if (class->instance_size <= sizeof (MonoObject) + sizeof (gpointer)) - class->min_align = MAX (class->min_align, class->instance_size - sizeof (MonoObject)); + if (klass->instance_size <= sizeof (MonoObject) + sizeof (gpointer)) + klass->min_align = MAX (klass->min_align, klass->instance_size - sizeof (MonoObject)); } } mono_memory_barrier (); - class->size_inited = 1; + klass->size_inited = 1; /* * Compute static field layout and size @@ -2060,43 +2096,40 @@ mono_class_layout_fields (MonoClass *class) gint32 align; guint32 size; - field = &class->fields [i]; + field = &klass->fields [i]; if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC) || field->type->attrs & FIELD_ATTRIBUTE_LITERAL) continue; if (mono_field_is_deleted (field)) continue; - // Special static fields do not need a domain-level static slot - if (mono_class_field_is_special_static (field)) - continue; if (mono_type_has_exceptions (field->type)) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); break; } has_static_fields = TRUE; size = mono_type_size (field->type, &align); - field->offset = class->sizes.class_size; + field->offset = klass->sizes.class_size; /*align is always non-zero here*/ field->offset += align - 1; field->offset &= ~(align - 1); - class->sizes.class_size = field->offset + size; + klass->sizes.class_size = field->offset + size; } - if (has_static_fields && class->sizes.class_size == 0) + if (has_static_fields && klass->sizes.class_size == 0) /* Simplify code which depends on class_size != 0 if the class has static fields */ - class->sizes.class_size = 8; + klass->sizes.class_size = 8; } static MonoMethod* -create_array_method (MonoClass *class, const char *name, MonoMethodSignature *sig) +create_array_method (MonoClass *klass, const char *name, MonoMethodSignature *sig) { MonoMethod *method; - method = (MonoMethod *) mono_image_alloc0 (class->image, sizeof (MonoMethodPInvoke)); - method->klass = class; + method = (MonoMethod *) mono_image_alloc0 (klass->image, sizeof (MonoMethodPInvoke)); + method->klass = klass; method->flags = METHOD_ATTRIBUTE_PUBLIC; method->iflags = METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL; method->signature = sig; @@ -2121,47 +2154,47 @@ create_array_method (MonoClass *class, const char *name, MonoMethodSignature *si * Methods belonging to an interface are assigned a sequential slot starting * from 0. * - * On failure this function sets class->exception_type + * On failure this function sets klass->exception_type */ void -mono_class_setup_methods (MonoClass *class) +mono_class_setup_methods (MonoClass *klass) { int i, count; MonoMethod **methods; - if (class->methods) + if (klass->methods) return; - if (class->generic_class) { + if (klass->generic_class) { MonoError error; - MonoClass *gklass = class->generic_class->container_class; + MonoClass *gklass = klass->generic_class->container_class; mono_class_init (gklass); - if (!gklass->exception_type) + if (!mono_class_has_failure (gklass)) mono_class_setup_methods (gklass); - if (gklass->exception_type) { + if (mono_class_has_failure (gklass)) { /* FIXME make exception_data less opaque so it's possible to dup it here */ - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load")); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load")); return; } /* The + 1 makes this always non-NULL to pass the check in mono_class_setup_methods () */ count = gklass->method.count; - methods = mono_class_alloc0 (class, sizeof (MonoMethod*) * (count + 1)); + methods = (MonoMethod **)mono_class_alloc0 (klass, sizeof (MonoMethod*) * (count + 1)); for (i = 0; i < count; i++) { methods [i] = mono_class_inflate_generic_method_full_checked ( - gklass->methods [i], class, mono_class_get_context (class), &error); + gklass->methods [i], klass, mono_class_get_context (klass), &error); if (!mono_error_ok (&error)) { char *method = mono_method_full_name (gklass->methods [i], TRUE); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Could not inflate method %s due to %s", method, mono_error_get_message (&error))); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Could not inflate method %s due to %s", method, mono_error_get_message (&error))); g_free (method); mono_error_cleanup (&error); return; } } - } else if (class->rank) { + } else if (klass->rank) { MonoError error; MonoMethod *amethod; MonoMethodSignature *sig; @@ -2169,104 +2202,104 @@ mono_class_setup_methods (MonoClass *class) int method_num = 0; gboolean jagged_ctor = FALSE; - count = 3 + (class->rank > 1? 2: 1); + count = 3 + (klass->rank > 1? 2: 1); - mono_class_setup_interfaces (class, &error); + mono_class_setup_interfaces (klass, &error); g_assert (mono_error_ok (&error)); /*FIXME can this fail for array types?*/ - if (class->rank == 1 && class->element_class->rank) { + if (klass->rank == 1 && klass->element_class->rank) { jagged_ctor = TRUE; - class->method.count ++; + klass->method.count ++; } - if (class->interface_count) { - count_generic = generic_array_methods (class); + if (klass->interface_count) { + count_generic = generic_array_methods (klass); first_generic = count; - count += class->interface_count * count_generic; + count += klass->interface_count * count_generic; } - methods = mono_class_alloc0 (class, sizeof (MonoMethod*) * count); + methods = (MonoMethod **)mono_class_alloc0 (klass, sizeof (MonoMethod*) * count); - sig = mono_metadata_signature_alloc (class->image, class->rank); + sig = mono_metadata_signature_alloc (klass->image, klass->rank); sig->ret = &mono_defaults.void_class->byval_arg; sig->pinvoke = TRUE; sig->hasthis = TRUE; - for (i = 0; i < class->rank; ++i) + for (i = 0; i < klass->rank; ++i) sig->params [i] = &mono_defaults.int32_class->byval_arg; - amethod = create_array_method (class, ".ctor", sig); + amethod = create_array_method (klass, ".ctor", sig); methods [method_num++] = amethod; - if (class->rank > 1) { - sig = mono_metadata_signature_alloc (class->image, class->rank * 2); + if (klass->rank > 1) { + sig = mono_metadata_signature_alloc (klass->image, klass->rank * 2); sig->ret = &mono_defaults.void_class->byval_arg; sig->pinvoke = TRUE; sig->hasthis = TRUE; - for (i = 0; i < class->rank * 2; ++i) + for (i = 0; i < klass->rank * 2; ++i) sig->params [i] = &mono_defaults.int32_class->byval_arg; - amethod = create_array_method (class, ".ctor", sig); + amethod = create_array_method (klass, ".ctor", sig); methods [method_num++] = amethod; } if (jagged_ctor) { /* Jagged arrays have an extra ctor in .net which creates an array of arrays */ - sig = mono_metadata_signature_alloc (class->image, class->rank + 1); + sig = mono_metadata_signature_alloc (klass->image, klass->rank + 1); sig->ret = &mono_defaults.void_class->byval_arg; sig->pinvoke = TRUE; sig->hasthis = TRUE; - for (i = 0; i < class->rank + 1; ++i) + for (i = 0; i < klass->rank + 1; ++i) sig->params [i] = &mono_defaults.int32_class->byval_arg; - amethod = create_array_method (class, ".ctor", sig); + amethod = create_array_method (klass, ".ctor", sig); methods [method_num++] = amethod; } /* element Get (idx11, [idx2, ...]) */ - sig = mono_metadata_signature_alloc (class->image, class->rank); - sig->ret = &class->element_class->byval_arg; + sig = mono_metadata_signature_alloc (klass->image, klass->rank); + sig->ret = &klass->element_class->byval_arg; sig->pinvoke = TRUE; sig->hasthis = TRUE; - for (i = 0; i < class->rank; ++i) + for (i = 0; i < klass->rank; ++i) sig->params [i] = &mono_defaults.int32_class->byval_arg; - amethod = create_array_method (class, "Get", sig); + amethod = create_array_method (klass, "Get", sig); methods [method_num++] = amethod; /* element& Address (idx11, [idx2, ...]) */ - sig = mono_metadata_signature_alloc (class->image, class->rank); - sig->ret = &class->element_class->this_arg; + sig = mono_metadata_signature_alloc (klass->image, klass->rank); + sig->ret = &klass->element_class->this_arg; sig->pinvoke = TRUE; sig->hasthis = TRUE; - for (i = 0; i < class->rank; ++i) + for (i = 0; i < klass->rank; ++i) sig->params [i] = &mono_defaults.int32_class->byval_arg; - amethod = create_array_method (class, "Address", sig); + amethod = create_array_method (klass, "Address", sig); methods [method_num++] = amethod; /* void Set (idx11, [idx2, ...], element) */ - sig = mono_metadata_signature_alloc (class->image, class->rank + 1); + sig = mono_metadata_signature_alloc (klass->image, klass->rank + 1); sig->ret = &mono_defaults.void_class->byval_arg; sig->pinvoke = TRUE; sig->hasthis = TRUE; - for (i = 0; i < class->rank; ++i) + for (i = 0; i < klass->rank; ++i) sig->params [i] = &mono_defaults.int32_class->byval_arg; - sig->params [i] = &class->element_class->byval_arg; - amethod = create_array_method (class, "Set", sig); + sig->params [i] = &klass->element_class->byval_arg; + amethod = create_array_method (klass, "Set", sig); methods [method_num++] = amethod; - for (i = 0; i < class->interface_count; i++) - setup_generic_array_ifaces (class, class->interfaces [i], methods, first_generic + i * count_generic); + for (i = 0; i < klass->interface_count; i++) + setup_generic_array_ifaces (klass, klass->interfaces [i], methods, first_generic + i * count_generic); } else { MonoError error; - count = class->method.count; - methods = mono_class_alloc (class, sizeof (MonoMethod*) * count); + count = klass->method.count; + methods = (MonoMethod **)mono_class_alloc (klass, sizeof (MonoMethod*) * count); for (i = 0; i < count; ++i) { - int idx = mono_metadata_translate_token_index (class->image, MONO_TABLE_METHOD, class->method.first + i + 1); - methods [i] = mono_get_method_checked (class->image, MONO_TOKEN_METHOD_DEF | idx, class, NULL, &error); + int idx = mono_metadata_translate_token_index (klass->image, MONO_TABLE_METHOD, klass->method.first + i + 1); + methods [i] = mono_get_method_checked (klass->image, MONO_TOKEN_METHOD_DEF | idx, klass, NULL, &error); if (!methods [i]) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Could not load method %d due to %s", i, mono_error_get_message (&error))); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Could not load method %d due to %s", i, mono_error_get_message (&error))); mono_error_cleanup (&error); } } } - if (MONO_CLASS_IS_INTERFACE (class)) { + if (MONO_CLASS_IS_INTERFACE (klass)) { int slot = 0; /*Only assign slots to virtual methods as interfaces are allowed to have static methods.*/ for (i = 0; i < count; ++i) { @@ -2275,38 +2308,38 @@ mono_class_setup_methods (MonoClass *class) } } - mono_image_lock (class->image); + mono_image_lock (klass->image); - if (!class->methods) { - class->method.count = count; + if (!klass->methods) { + klass->method.count = count; /* Needed because of the double-checking locking pattern */ mono_memory_barrier (); - class->methods = methods; + klass->methods = methods; } - mono_image_unlock (class->image); + mono_image_unlock (klass->image); } /* * mono_class_get_method_by_index: * - * Returns class->methods [index], initializing class->methods if neccesary. + * Returns klass->methods [index], initializing klass->methods if neccesary. * * LOCKING: Acquires the loader lock. */ MonoMethod* -mono_class_get_method_by_index (MonoClass *class, int index) +mono_class_get_method_by_index (MonoClass *klass, int index) { MonoError error; /* Avoid calling setup_methods () if possible */ - if (class->generic_class && !class->methods) { - MonoClass *gklass = class->generic_class->container_class; + if (klass->generic_class && !klass->methods) { + MonoClass *gklass = klass->generic_class->container_class; MonoMethod *m; m = mono_class_inflate_generic_method_full_checked ( - gklass->methods [index], class, mono_class_get_context (class), &error); + gklass->methods [index], klass, mono_class_get_context (klass), &error); g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */ /* * If setup_methods () is called later for this class, no duplicates are created, @@ -2314,16 +2347,16 @@ mono_class_get_method_by_index (MonoClass *class, int index) * is created for each context. */ /* - mono_class_setup_methods (class); - g_assert (m == class->methods [index]); + mono_class_setup_methods (klass); + g_assert (m == klass->methods [index]); */ return m; } else { - mono_class_setup_methods (class); - if (class->exception_type) /*FIXME do proper error handling*/ + mono_class_setup_methods (klass); + if (mono_class_has_failure (klass)) /*FIXME do proper error handling*/ return NULL; - g_assert (index >= 0 && index < class->method.count); - return class->methods [index]; + g_assert (index >= 0 && index < klass->method.count); + return klass->methods [index]; } } @@ -2334,23 +2367,23 @@ mono_class_get_method_by_index (MonoClass *class, int index) * CLASS's generic definition, return the inflated method corresponding to METHOD. */ MonoMethod* -mono_class_get_inflated_method (MonoClass *class, MonoMethod *method) +mono_class_get_inflated_method (MonoClass *klass, MonoMethod *method) { - MonoClass *gklass = class->generic_class->container_class; + MonoClass *gklass = klass->generic_class->container_class; int i; g_assert (method->klass == gklass); mono_class_setup_methods (gklass); - g_assert (!gklass->exception_type); /*FIXME do proper error handling*/ + g_assert (!mono_class_has_failure (gklass)); /*FIXME do proper error handling*/ for (i = 0; i < gklass->method.count; ++i) { if (gklass->methods [i] == method) { - if (class->methods) { - return class->methods [i]; + if (klass->methods) { + return klass->methods [i]; } else { MonoError error; - MonoMethod *result = mono_class_inflate_generic_method_full_checked (gklass->methods [i], class, mono_class_get_context (class), &error); + MonoMethod *result = mono_class_inflate_generic_method_full_checked (gklass->methods [i], klass, mono_class_get_context (klass), &error); g_assert (mono_error_ok (&error)); /* FIXME don't swallow this error */ return result; } @@ -2363,37 +2396,37 @@ mono_class_get_inflated_method (MonoClass *class, MonoMethod *method) /* * mono_class_get_vtable_entry: * - * Returns class->vtable [offset], computing it if neccesary. Returns NULL on failure. + * Returns klass->vtable [offset], computing it if neccesary. Returns NULL on failure. * LOCKING: Acquires the loader lock. */ MonoMethod* -mono_class_get_vtable_entry (MonoClass *class, int offset) +mono_class_get_vtable_entry (MonoClass *klass, int offset) { MonoMethod *m; - if (class->rank == 1) { + if (klass->rank == 1) { /* * szarrays do not overwrite any methods of Array, so we can avoid * initializing their vtables in some cases. */ - mono_class_setup_vtable (class->parent); - if (offset < class->parent->vtable_size) - return class->parent->vtable [offset]; + mono_class_setup_vtable (klass->parent); + if (offset < klass->parent->vtable_size) + return klass->parent->vtable [offset]; } - if (class->generic_class) { + if (klass->generic_class) { MonoError error; - MonoClass *gklass = class->generic_class->container_class; + MonoClass *gklass = klass->generic_class->container_class; mono_class_setup_vtable (gklass); m = gklass->vtable [offset]; - m = mono_class_inflate_generic_method_full_checked (m, class, mono_class_get_context (class), &error); + m = mono_class_inflate_generic_method_full_checked (m, klass, mono_class_get_context (klass), &error); g_assert (mono_error_ok (&error)); /* FIXME don't swallow this error */ } else { - mono_class_setup_vtable (class); - if (class->exception_type) + mono_class_setup_vtable (klass); + if (mono_class_has_failure (klass)) return NULL; - m = class->vtable [offset]; + m = klass->vtable [offset]; } return m; @@ -2415,34 +2448,34 @@ mono_class_get_vtable_size (MonoClass *klass) /* * mono_class_setup_properties: * - * Initialize class->ext.property and class->ext.properties. + * Initialize klass->ext.property and klass->ext.properties. * * This method can fail the class. */ static void -mono_class_setup_properties (MonoClass *class) +mono_class_setup_properties (MonoClass *klass) { guint startm, endm, i, j; guint32 cols [MONO_PROPERTY_SIZE]; - MonoTableInfo *msemt = &class->image->tables [MONO_TABLE_METHODSEMANTICS]; + MonoTableInfo *msemt = &klass->image->tables [MONO_TABLE_METHODSEMANTICS]; MonoProperty *properties; guint32 last; int first, count; - if (class->ext && class->ext->properties) + if (klass->ext && klass->ext->properties) return; - if (class->generic_class) { - MonoClass *gklass = class->generic_class->container_class; + if (klass->generic_class) { + MonoClass *gklass = klass->generic_class->container_class; mono_class_init (gklass); mono_class_setup_properties (gklass); - if (gklass->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load")); + if (mono_class_has_failure (gklass)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load")); return; } - properties = mono_class_new0 (class, MonoProperty, gklass->ext->property.count + 1); + properties = mono_class_new0 (klass, MonoProperty, gklass->ext->property.count + 1); for (i = 0; i < gklass->ext->property.count; i++) { MonoError error; @@ -2452,47 +2485,47 @@ mono_class_setup_properties (MonoClass *class) if (prop->get) prop->get = mono_class_inflate_generic_method_full_checked ( - prop->get, class, mono_class_get_context (class), &error); + prop->get, klass, mono_class_get_context (klass), &error); if (prop->set) prop->set = mono_class_inflate_generic_method_full_checked ( - prop->set, class, mono_class_get_context (class), &error); + prop->set, klass, mono_class_get_context (klass), &error); g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/ - prop->parent = class; + prop->parent = klass; } first = gklass->ext->property.first; count = gklass->ext->property.count; } else { - first = mono_metadata_properties_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last); + first = mono_metadata_properties_from_typedef (klass->image, mono_metadata_token_index (klass->type_token) - 1, &last); count = last - first; if (count) { - mono_class_setup_methods (class); - if (class->exception_type) + mono_class_setup_methods (klass); + if (mono_class_has_failure (klass)) return; } - properties = mono_class_alloc0 (class, sizeof (MonoProperty) * count); + properties = (MonoProperty *)mono_class_alloc0 (klass, sizeof (MonoProperty) * count); for (i = first; i < last; ++i) { - mono_metadata_decode_table_row (class->image, MONO_TABLE_PROPERTY, i, cols, MONO_PROPERTY_SIZE); - properties [i - first].parent = class; + mono_metadata_decode_table_row (klass->image, MONO_TABLE_PROPERTY, i, cols, MONO_PROPERTY_SIZE); + properties [i - first].parent = klass; properties [i - first].attrs = cols [MONO_PROPERTY_FLAGS]; - properties [i - first].name = mono_metadata_string_heap (class->image, cols [MONO_PROPERTY_NAME]); + properties [i - first].name = mono_metadata_string_heap (klass->image, cols [MONO_PROPERTY_NAME]); - startm = mono_metadata_methods_from_property (class->image, i, &endm); + startm = mono_metadata_methods_from_property (klass->image, i, &endm); for (j = startm; j < endm; ++j) { MonoMethod *method; mono_metadata_decode_row (msemt, j, cols, MONO_METHOD_SEMA_SIZE); - if (class->image->uncompressed_metadata) { + if (klass->image->uncompressed_metadata) { MonoError error; /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */ - method = mono_get_method_checked (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class, NULL, &error); + method = mono_get_method_checked (klass->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], klass, NULL, &error); mono_error_cleanup (&error); /* FIXME don't swallow this error */ } else { - method = class->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - class->method.first]; + method = klass->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - klass->method.first]; } switch (cols [MONO_METHOD_SEMA_SEMANTICS]) { @@ -2509,30 +2542,30 @@ mono_class_setup_properties (MonoClass *class) } } - mono_class_alloc_ext (class); + mono_class_alloc_ext (klass); - mono_image_lock (class->image); + mono_image_lock (klass->image); - if (class->ext->properties) { + if (klass->ext->properties) { /* We leak 'properties' which was allocated from the image mempool */ - mono_image_unlock (class->image); + mono_image_unlock (klass->image); return; } - class->ext->property.first = first; - class->ext->property.count = count; + klass->ext->property.first = first; + klass->ext->property.count = count; - /* Flush any pending writes as we do double checked locking on class->ext->properties */ + /* Flush any pending writes as we do double checked locking on klass->ext->properties */ mono_memory_barrier (); /* Leave this assignment as the last op in the function */ - class->ext->properties = properties; + klass->ext->properties = properties; - mono_image_unlock (class->image); + mono_image_unlock (klass->image); } static MonoMethod** -inflate_method_listz (MonoMethod **methods, MonoClass *class, MonoGenericContext *context) +inflate_method_listz (MonoMethod **methods, MonoClass *klass, MonoGenericContext *context) { MonoMethod **om, **retval; int count; @@ -2544,7 +2577,7 @@ inflate_method_listz (MonoMethod **methods, MonoClass *class, MonoGenericContext count = 0; for (om = methods, count = 0; *om; ++om, ++count) { MonoError error; - retval [count] = mono_class_inflate_generic_method_full_checked (*om, class, context, &error); + retval [count] = mono_class_inflate_generic_method_full_checked (*om, klass, context, &error); g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/ } @@ -2553,35 +2586,35 @@ inflate_method_listz (MonoMethod **methods, MonoClass *class, MonoGenericContext /*This method can fail the class.*/ static void -mono_class_setup_events (MonoClass *class) +mono_class_setup_events (MonoClass *klass) { int first, count; guint startm, endm, i, j; guint32 cols [MONO_EVENT_SIZE]; - MonoTableInfo *msemt = &class->image->tables [MONO_TABLE_METHODSEMANTICS]; + MonoTableInfo *msemt = &klass->image->tables [MONO_TABLE_METHODSEMANTICS]; guint32 last; MonoEvent *events; - if (class->ext && class->ext->events) + if (klass->ext && klass->ext->events) return; - if (class->generic_class) { - MonoClass *gklass = class->generic_class->container_class; + if (klass->generic_class) { + MonoClass *gklass = klass->generic_class->container_class; MonoGenericContext *context = NULL; mono_class_setup_events (gklass); - if (gklass->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load")); + if (mono_class_has_failure (gklass)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load")); return; } first = gklass->ext->event.first; count = gklass->ext->event.count; - events = mono_class_new0 (class, MonoEvent, count); + events = mono_class_new0 (klass, MonoEvent, count); if (count) - context = mono_class_get_context (class); + context = mono_class_get_context (klass); for (i = 0; i < count; i++) { MonoError error; @@ -2590,54 +2623,54 @@ mono_class_setup_events (MonoClass *class) mono_error_init (&error); //since we do conditional calls, we must ensure the default value is ok - event->parent = class; + event->parent = klass; event->name = gevent->name; - event->add = gevent->add ? mono_class_inflate_generic_method_full_checked (gevent->add, class, context, &error) : NULL; + event->add = gevent->add ? mono_class_inflate_generic_method_full_checked (gevent->add, klass, context, &error) : NULL; g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/ - event->remove = gevent->remove ? mono_class_inflate_generic_method_full_checked (gevent->remove, class, context, &error) : NULL; + event->remove = gevent->remove ? mono_class_inflate_generic_method_full_checked (gevent->remove, klass, context, &error) : NULL; g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/ - event->raise = gevent->raise ? mono_class_inflate_generic_method_full_checked (gevent->raise, class, context, &error) : NULL; + event->raise = gevent->raise ? mono_class_inflate_generic_method_full_checked (gevent->raise, klass, context, &error) : NULL; g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/ #ifndef MONO_SMALL_CONFIG - event->other = gevent->other ? inflate_method_listz (gevent->other, class, context) : NULL; + event->other = gevent->other ? inflate_method_listz (gevent->other, klass, context) : NULL; #endif event->attrs = gevent->attrs; } } else { - first = mono_metadata_events_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &last); + first = mono_metadata_events_from_typedef (klass->image, mono_metadata_token_index (klass->type_token) - 1, &last); count = last - first; if (count) { - mono_class_setup_methods (class); - if (class->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load")); + mono_class_setup_methods (klass); + if (mono_class_has_failure (klass)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Generic type definition failed to load")); return; } } - events = mono_class_alloc0 (class, sizeof (MonoEvent) * count); + events = (MonoEvent *)mono_class_alloc0 (klass, sizeof (MonoEvent) * count); for (i = first; i < last; ++i) { MonoEvent *event = &events [i - first]; - mono_metadata_decode_table_row (class->image, MONO_TABLE_EVENT, i, cols, MONO_EVENT_SIZE); - event->parent = class; + mono_metadata_decode_table_row (klass->image, MONO_TABLE_EVENT, i, cols, MONO_EVENT_SIZE); + event->parent = klass; event->attrs = cols [MONO_EVENT_FLAGS]; - event->name = mono_metadata_string_heap (class->image, cols [MONO_EVENT_NAME]); + event->name = mono_metadata_string_heap (klass->image, cols [MONO_EVENT_NAME]); - startm = mono_metadata_methods_from_event (class->image, i, &endm); + startm = mono_metadata_methods_from_event (klass->image, i, &endm); for (j = startm; j < endm; ++j) { MonoMethod *method; mono_metadata_decode_row (msemt, j, cols, MONO_METHOD_SEMA_SIZE); - if (class->image->uncompressed_metadata) { + if (klass->image->uncompressed_metadata) { MonoError error; /* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */ - method = mono_get_method_checked (class->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], class, NULL, &error); + method = mono_get_method_checked (klass->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], klass, NULL, &error); mono_error_cleanup (&error); /* FIXME don't swallow this error */ } else { - method = class->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - class->method.first]; + method = klass->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - klass->method.first]; } switch (cols [MONO_METHOD_SEMA_SEMANTICS]) { @@ -2659,7 +2692,7 @@ mono_class_setup_events (MonoClass *class) } else { while (event->other [n]) n++; - event->other = g_realloc (event->other, (n + 2) * sizeof (MonoMethod*)); + event->other = (MonoMethod **)g_realloc (event->other, (n + 2) * sizeof (MonoMethod*)); } event->other [n] = method; /* NULL terminated */ @@ -2674,25 +2707,25 @@ mono_class_setup_events (MonoClass *class) } } - mono_class_alloc_ext (class); + mono_class_alloc_ext (klass); - mono_image_lock (class->image); + mono_image_lock (klass->image); - if (class->ext->events) { - mono_image_unlock (class->image); + if (klass->ext->events) { + mono_image_unlock (klass->image); return; } - class->ext->event.first = first; - class->ext->event.count = count; + klass->ext->event.first = first; + klass->ext->event.count = count; - /* Flush any pending writes as we do double checked locking on class->ext.events */ + /* Flush any pending writes as we do double checked locking on klass->ext.events */ mono_memory_barrier (); /* Leave this assignment as the last op in the function */ - class->ext->events = events; + klass->ext->events = events; - mono_image_unlock (class->image); + mono_image_unlock (klass->image); } /* @@ -2718,30 +2751,30 @@ mono_unload_interface_ids (MonoBitSet *bitset) } void -mono_unload_interface_id (MonoClass *class) +mono_unload_interface_id (MonoClass *klass) { - if (global_interface_bitset && class->interface_id) { + if (global_interface_bitset && klass->interface_id) { classes_lock (); - mono_bitset_clear (global_interface_bitset, class->interface_id); + mono_bitset_clear (global_interface_bitset, klass->interface_id); classes_unlock (); } } -/* +/** * mono_get_unique_iid: * @class: interface * * Assign a unique integer ID to the interface represented by @class. * The ID will positive and as small as possible. * LOCKING: Acquires the classes lock. - * Returns: the new ID. + * Returns: The new ID. */ static guint -mono_get_unique_iid (MonoClass *class) +mono_get_unique_iid (MonoClass *klass) { int iid; - g_assert (MONO_CLASS_IS_INTERFACE (class)); + g_assert (MONO_CLASS_IS_INTERFACE (klass)); classes_lock (); @@ -2759,17 +2792,17 @@ mono_get_unique_iid (MonoClass *class) } mono_bitset_set (global_interface_bitset, iid); /* set the bit also in the per-image set */ - if (!class->generic_class) { - if (class->image->interface_bitset) { - if (iid >= mono_bitset_size (class->image->interface_bitset)) { - MonoBitSet *new_set = mono_bitset_clone (class->image->interface_bitset, iid + 1); - mono_bitset_free (class->image->interface_bitset); - class->image->interface_bitset = new_set; + if (!klass->generic_class) { + if (klass->image->interface_bitset) { + if (iid >= mono_bitset_size (klass->image->interface_bitset)) { + MonoBitSet *new_set = mono_bitset_clone (klass->image->interface_bitset, iid + 1); + mono_bitset_free (klass->image->interface_bitset); + klass->image->interface_bitset = new_set; } } else { - class->image->interface_bitset = mono_bitset_new (iid + 1, 0); + klass->image->interface_bitset = mono_bitset_new (iid + 1, 0); } - mono_bitset_set (class->image->interface_bitset, iid); + mono_bitset_set (klass->image->interface_bitset, iid); } classes_unlock (); @@ -2777,14 +2810,14 @@ mono_get_unique_iid (MonoClass *class) #ifndef MONO_SMALL_CONFIG if (mono_print_vtable) { int generic_id; - char *type_name = mono_type_full_name (&class->byval_arg); - if (class->generic_class && !class->generic_class->context.class_inst->is_open) { - generic_id = class->generic_class->context.class_inst->id; + char *type_name = mono_type_full_name (&klass->byval_arg); + if (klass->generic_class && !klass->generic_class->context.class_inst->is_open) { + generic_id = klass->generic_class->context.class_inst->id; g_assert (generic_id != 0); } else { generic_id = 0; } - printf ("Interface: assigned id %d to %s|%s|%d\n", iid, class->image->name, type_name, generic_id); + printf ("Interface: assigned id %d to %s|%s|%d\n", iid, klass->image->name, type_name, generic_id); g_free (type_name); } #endif @@ -2800,8 +2833,7 @@ collect_implemented_interfaces_aux (MonoClass *klass, GPtrArray **res, MonoError MonoClass *ic; mono_class_setup_interfaces (klass, error); - if (!mono_error_ok (error)) - return; + return_if_nok (error); for (i = 0; i < klass->interface_count; i++) { ic = klass->interfaces [i]; @@ -2810,14 +2842,13 @@ collect_implemented_interfaces_aux (MonoClass *klass, GPtrArray **res, MonoError *res = g_ptr_array_new (); g_ptr_array_add (*res, ic); mono_class_init (ic); - if (ic->exception_type) { + if (mono_class_has_failure (ic)) { mono_error_set_type_load_class (error, ic, "Error Loading class"); return; } collect_implemented_interfaces_aux (ic, res, error); - if (!mono_error_ok (error)) - return; + return_if_nok (error); } } @@ -2837,8 +2868,8 @@ mono_class_get_implemented_interfaces (MonoClass *klass, MonoError *error) static int compare_interface_ids (const void *p_key, const void *p_element) { - const MonoClass *key = p_key; - const MonoClass *element = *(MonoClass**) p_element; + const MonoClass *key = (const MonoClass *)p_key; + const MonoClass *element = *(const MonoClass **)p_element; return (key->interface_id - element->interface_id); } @@ -2846,7 +2877,7 @@ compare_interface_ids (const void *p_key, const void *p_element) { /*FIXME verify all callers if they should switch to mono_class_interface_offset_with_variance*/ int mono_class_interface_offset (MonoClass *klass, MonoClass *itf) { - MonoClass **result = mono_binary_search ( + MonoClass **result = (MonoClass **)mono_binary_search ( itf, klass->interfaces_packed, klass->interface_offsets_count, @@ -2859,7 +2890,7 @@ mono_class_interface_offset (MonoClass *klass, MonoClass *itf) { } } -/* +/** * mono_class_interface_offset_with_variance: * * Return the interface offset of @itf in @klass. Sets @non_exact_match to TRUE if the match required variance check @@ -2939,7 +2970,7 @@ print_implemented_interfaces (MonoClass *klass) { mono_error_cleanup (&error); } else if (ifaces) { for (i = 0; i < ifaces->len; i++) { - MonoClass *ic = g_ptr_array_index (ifaces, i); + MonoClass *ic = (MonoClass *)g_ptr_array_index (ifaces, i); printf (" [UIID %d] interface %s\n", ic->interface_id, ic->name); printf (" [%03d][UUID %03d][SLOT %03d][SIZE %03d] interface %s.%s\n", i, ic->interface_id, @@ -2965,9 +2996,9 @@ inflate_class_one_arg (MonoClass *gtype, MonoClass *arg0) } static MonoClass* -array_class_get_if_rank (MonoClass *class, guint rank) +array_class_get_if_rank (MonoClass *klass, guint rank) { - return rank ? mono_array_class_get (class, rank) : class; + return rank ? mono_array_class_get (klass, rank) : klass; } static void @@ -3008,9 +3039,9 @@ fill_valuetype_array_derived_types (MonoClass **valuetype_types, MonoClass *ecla * Fixing this should kill quite some code, save some bits and improve compatibility. */ static MonoClass** -get_implicit_generic_array_interfaces (MonoClass *class, int *num, int *is_enumerator) +get_implicit_generic_array_interfaces (MonoClass *klass, int *num, int *is_enumerator) { - MonoClass *eclass = class->element_class; + MonoClass *eclass = klass->element_class; static MonoClass* generic_icollection_class = NULL; static MonoClass* generic_ienumerable_class = NULL; static MonoClass* generic_ienumerator_class = NULL; @@ -3030,12 +3061,12 @@ get_implicit_generic_array_interfaces (MonoClass *class, int *num, int *is_enume internal_enumerator = FALSE; eclass_is_valuetype = FALSE; original_rank = eclass->rank; - if (class->byval_arg.type != MONO_TYPE_SZARRAY) { - if (class->generic_class && class->nested_in == mono_defaults.array_class && strcmp (class->name, "InternalEnumerator`1") == 0) { + if (klass->byval_arg.type != MONO_TYPE_SZARRAY) { + if (klass->generic_class && klass->nested_in == mono_defaults.array_class && strcmp (klass->name, "InternalEnumerator`1") == 0) { /* * For a Enumerator we need to get the list of interfaces for T. */ - eclass = mono_class_from_mono_type (class->generic_class->context.class_inst->type_argv [0]); + eclass = mono_class_from_mono_type (klass->generic_class->context.class_inst->type_argv [0]); original_rank = eclass->rank; if (!eclass->rank) eclass = eclass->element_class; @@ -3054,15 +3085,15 @@ get_implicit_generic_array_interfaces (MonoClass *class, int *num, int *is_enume all_interfaces = eclass->rank && eclass->element_class->rank? FALSE: TRUE; if (!generic_icollection_class) { - generic_icollection_class = mono_class_from_name (mono_defaults.corlib, + generic_icollection_class = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "ICollection`1"); - generic_ienumerable_class = mono_class_from_name (mono_defaults.corlib, + generic_ienumerable_class = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "IEnumerable`1"); - generic_ienumerator_class = mono_class_from_name (mono_defaults.corlib, + generic_ienumerator_class = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "IEnumerator`1"); - generic_ireadonlylist_class = mono_class_from_name (mono_defaults.corlib, + generic_ireadonlylist_class = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "IReadOnlyList`1"); - generic_ireadonlycollection_class = mono_class_from_name (mono_defaults.corlib, + generic_ireadonlycollection_class = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "IReadOnlyCollection`1"); } @@ -3091,7 +3122,7 @@ get_implicit_generic_array_interfaces (MonoClass *class, int *num, int *is_enume ++real_count; } - interfaces = g_malloc0 (sizeof (MonoClass*) * real_count); + interfaces = (MonoClass **)g_malloc0 (sizeof (MonoClass*) * real_count); interfaces [0] = valuetype_types [0]; if (valuetype_types [1]) interfaces [nifaces] = valuetype_types [1]; @@ -3131,7 +3162,7 @@ get_implicit_generic_array_interfaces (MonoClass *class, int *num, int *is_enume if (valuetype_types [1]) ++real_count; } - interfaces = g_malloc0 (sizeof (MonoClass*) * real_count); + interfaces = (MonoClass **)g_malloc0 (sizeof (MonoClass*) * real_count); if (MONO_CLASS_IS_INTERFACE (eclass)) { interfaces [0] = mono_defaults.object_class; j = nifaces; @@ -3207,7 +3238,7 @@ get_implicit_generic_array_interfaces (MonoClass *class, int *num, int *is_enume } #if 0 { - char *type_name = mono_type_get_name_full (&class->byval_arg, 0); + char *type_name = mono_type_get_name_full (&klass->byval_arg, 0); for (i = 0; i < real_count; ++i) { char *name = mono_type_get_name_full (&interfaces [i]->byval_arg, 0); g_print ("%s implements %s\n", type_name, name); @@ -3238,25 +3269,25 @@ find_array_interface (MonoClass *klass, const char *name) * FIXME It would be nice if this information could be cached somewhere. */ static int -count_virtual_methods (MonoClass *class) +count_virtual_methods (MonoClass *klass) { int i, count = 0; guint32 flags; - class = mono_class_get_generic_type_definition (class); /*We can find this information by looking at the GTD*/ + klass = mono_class_get_generic_type_definition (klass); /*We can find this information by looking at the GTD*/ - if (class->methods || !MONO_CLASS_HAS_STATIC_METADATA (class)) { - mono_class_setup_methods (class); - if (class->exception_type) + if (klass->methods || !MONO_CLASS_HAS_STATIC_METADATA (klass)) { + mono_class_setup_methods (klass); + if (mono_class_has_failure (klass)) return -1; - for (i = 0; i < class->method.count; ++i) { - flags = class->methods [i]->flags; + for (i = 0; i < klass->method.count; ++i) { + flags = klass->methods [i]->flags; if (flags & METHOD_ATTRIBUTE_VIRTUAL) ++count; } } else { - for (i = 0; i < class->method.count; ++i) { - flags = mono_metadata_decode_table_row_col (class->image, MONO_TABLE_METHOD, class->method.first + i, MONO_METHOD_FLAGS); + for (i = 0; i < klass->method.count; ++i) { + flags = mono_metadata_decode_table_row_col (klass->image, MONO_TABLE_METHOD, klass->method.first + i, MONO_METHOD_FLAGS); if (flags & METHOD_ATTRIBUTE_VIRTUAL) ++count; @@ -3368,7 +3399,7 @@ set_interface_and_offset (int num_ifaces, MonoClass **interfaces_full, int *inte * the size of the buffer. * This compression algorithm assumes the bits set in the bitmap are * few and far between, like in interface bitmaps. - * Returns: the size of the compressed bitmap in bytes. + * Returns: The size of the compressed bitmap in bytes. */ int mono_compress_bitmap (uint8_t *dest, const uint8_t *bitmap, int size) @@ -3410,7 +3441,7 @@ mono_compress_bitmap (uint8_t *dest, const uint8_t *bitmap, int size) * be already checked for being smaller than the maximum id encoded in the * bitmap. * - * Returns: a non-zero value if bit @id is set in the bitmap @bitmap, + * Returns: A non-zero value if bit @id is set in the bitmap @bitmap, * #FALSE otherwise. */ int @@ -3434,7 +3465,7 @@ mono_class_interface_match (const uint8_t *bitmap, int id) * Return -1 on failure and set exception_type */ static int -setup_interface_offsets (MonoClass *class, int cur_slot, gboolean overwrite) +setup_interface_offsets (MonoClass *klass, int cur_slot, gboolean overwrite) { MonoError error; MonoClass *k, *ic; @@ -3448,20 +3479,20 @@ setup_interface_offsets (MonoClass *class, int cur_slot, gboolean overwrite) int num_array_interfaces; int is_enumerator = FALSE; - mono_class_setup_supertypes (class); + mono_class_setup_supertypes (klass); /* * get the implicit generic interfaces for either the arrays or for System.Array/InternalEnumerator * implicit interfaces have the property that they are assigned the same slot in the * vtables for compatible interfaces */ - array_interfaces = get_implicit_generic_array_interfaces (class, &num_array_interfaces, &is_enumerator); + array_interfaces = get_implicit_generic_array_interfaces (klass, &num_array_interfaces, &is_enumerator); /* compute maximum number of slots and maximum interface id */ max_iid = 0; num_ifaces = num_array_interfaces; /* this can include duplicated ones */ - ifaces_array = g_new0 (GPtrArray *, class->idepth); - for (j = 0; j < class->idepth; j++) { - k = class->supertypes [j]; + ifaces_array = g_new0 (GPtrArray *, klass->idepth); + for (j = 0; j < klass->idepth; j++) { + k = klass->supertypes [j]; num_ifaces += k->interface_count; for (i = 0; i < k->interface_count; i++) { ic = k->interfaces [i]; @@ -3475,7 +3506,7 @@ setup_interface_offsets (MonoClass *class, int cur_slot, gboolean overwrite) ifaces = mono_class_get_implemented_interfaces (k, &error); if (!mono_error_ok (&error)) { char *name = mono_type_get_full_name (k); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Error getting the interfaces of %s due to %s", name, mono_error_get_message (&error))); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Error getting the interfaces of %s due to %s", name, mono_error_get_message (&error))); g_free (name); mono_error_cleanup (&error); cur_slot = -1; @@ -3484,7 +3515,7 @@ setup_interface_offsets (MonoClass *class, int cur_slot, gboolean overwrite) if (ifaces) { num_ifaces += ifaces->len; for (i = 0; i < ifaces->len; ++i) { - ic = g_ptr_array_index (ifaces, i); + ic = (MonoClass *)g_ptr_array_index (ifaces, i); if (max_iid < ic->interface_id) max_iid = ic->interface_id; } @@ -3499,29 +3530,29 @@ setup_interface_offsets (MonoClass *class, int cur_slot, gboolean overwrite) max_iid = ic->interface_id; } - if (MONO_CLASS_IS_INTERFACE (class)) { + if (MONO_CLASS_IS_INTERFACE (klass)) { num_ifaces++; - if (max_iid < class->interface_id) - max_iid = class->interface_id; + if (max_iid < klass->interface_id) + max_iid = klass->interface_id; } - class->max_interface_id = max_iid; + klass->max_interface_id = max_iid; /* compute vtable offset for interfaces */ - interfaces_full = g_malloc0 (sizeof (MonoClass*) * num_ifaces); - interface_offsets_full = g_malloc (sizeof (int) * num_ifaces); + interfaces_full = (MonoClass **)g_malloc0 (sizeof (MonoClass*) * num_ifaces); + interface_offsets_full = (int *)g_malloc (sizeof (int) * num_ifaces); for (i = 0; i < num_ifaces; i++) { interface_offsets_full [i] = -1; } /* skip the current class */ - for (j = 0; j < class->idepth - 1; j++) { - k = class->supertypes [j]; + for (j = 0; j < klass->idepth - 1; j++) { + k = klass->supertypes [j]; ifaces = ifaces_array [j]; if (ifaces) { for (i = 0; i < ifaces->len; ++i) { int io; - ic = g_ptr_array_index (ifaces, i); + ic = (MonoClass *)g_ptr_array_index (ifaces, i); /*Force the sharing of interface offsets between parent and subtypes.*/ io = mono_class_interface_offset (k, ic); @@ -3531,18 +3562,18 @@ setup_interface_offsets (MonoClass *class, int cur_slot, gboolean overwrite) } } - g_assert (class == class->supertypes [class->idepth - 1]); - ifaces = ifaces_array [class->idepth - 1]; + g_assert (klass == klass->supertypes [klass->idepth - 1]); + ifaces = ifaces_array [klass->idepth - 1]; if (ifaces) { for (i = 0; i < ifaces->len; ++i) { int count; - ic = g_ptr_array_index (ifaces, i); + ic = (MonoClass *)g_ptr_array_index (ifaces, i); if (set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, cur_slot, FALSE)) continue; count = count_virtual_methods (ic); if (count == -1) { char *name = mono_type_get_full_name (ic); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Error calculating interface offset of %s", name)); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Error calculating interface offset of %s", name)); g_free (name); cur_slot = -1; goto end; @@ -3551,13 +3582,13 @@ setup_interface_offsets (MonoClass *class, int cur_slot, gboolean overwrite) } } - if (MONO_CLASS_IS_INTERFACE (class)) - set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, class, cur_slot, TRUE); + if (MONO_CLASS_IS_INTERFACE (klass)) + set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, klass, cur_slot, TRUE); if (num_array_interfaces) { if (is_enumerator) { - int ienumerator_idx = find_array_interface (class, "IEnumerator`1"); - int ienumerator_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, class->interfaces [ienumerator_idx]); + int ienumerator_idx = find_array_interface (klass, "IEnumerator`1"); + int ienumerator_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, klass->interfaces [ienumerator_idx]); g_assert (ienumerator_offset >= 0); for (i = 0; i < num_array_interfaces; ++i) { ic = array_interfaces [i]; @@ -3565,21 +3596,21 @@ setup_interface_offsets (MonoClass *class, int cur_slot, gboolean overwrite) set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, ienumerator_offset, TRUE); else g_assert_not_reached (); - /*g_print ("type %s has %s offset at %d (%s)\n", class->name, ic->name, interface_offsets_full [ic->interface_id], class->interfaces [0]->name);*/ + /*g_print ("type %s has %s offset at %d (%s)\n", klass->name, ic->name, interface_offsets_full [ic->interface_id], klass->interfaces [0]->name);*/ } } else { int ilist_offset, icollection_offset, ienumerable_offset, ireadonlylist_offset, ireadonlycollection_offset; - int ilist_iface_idx = find_array_interface (class, "IList`1"); - MonoClass* ilist_class = class->interfaces [ilist_iface_idx]; - int ireadonlylist_iface_idx = find_array_interface (class, "IReadOnlyList`1"); - MonoClass* ireadonlylist_class = ireadonlylist_iface_idx != -1 ? class->interfaces [ireadonlylist_iface_idx] : NULL; + int ilist_iface_idx = find_array_interface (klass, "IList`1"); + MonoClass* ilist_class = klass->interfaces [ilist_iface_idx]; + int ireadonlylist_iface_idx = find_array_interface (klass, "IReadOnlyList`1"); + MonoClass* ireadonlylist_class = ireadonlylist_iface_idx != -1 ? klass->interfaces [ireadonlylist_iface_idx] : NULL; int icollection_iface_idx = find_array_interface (ilist_class, "ICollection`1"); int ienumerable_iface_idx = find_array_interface (ilist_class, "IEnumerable`1"); int ireadonlycollection_iface_idx = ireadonlylist_iface_idx != -1 ? find_array_interface (ireadonlylist_class, "IReadOnlyCollection`1") : -1; - ilist_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, class->interfaces [ilist_iface_idx]); + ilist_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, klass->interfaces [ilist_iface_idx]); icollection_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, ilist_class->interfaces [icollection_iface_idx]); ienumerable_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, ilist_class->interfaces [ienumerable_iface_idx]); - ireadonlylist_offset = ireadonlylist_iface_idx != -1 ? find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, class->interfaces [ireadonlylist_iface_idx]) : -1; + ireadonlylist_offset = ireadonlylist_iface_idx != -1 ? find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, klass->interfaces [ireadonlylist_iface_idx]) : -1; ireadonlycollection_offset = ireadonlycollection_iface_idx != -1 ? find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, ireadonlylist_class->interfaces [ireadonlycollection_iface_idx]) : -1; g_assert (ilist_offset >= 0 && icollection_offset >= 0 && ienumerable_offset >= 0); for (i = 0; i < num_array_interfaces; ++i) { @@ -3598,7 +3629,7 @@ setup_interface_offsets (MonoClass *class, int cur_slot, gboolean overwrite) else g_assert_not_reached (); set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, offset, TRUE); - /*g_print ("type %s has %s offset at %d (%s)\n", class->name, ic->name, offset, class->interfaces [0]->name);*/ + /*g_print ("type %s has %s offset at %d (%s)\n", klass->name, ic->name, offset, klass->interfaces [0]->name);*/ } } } @@ -3617,36 +3648,36 @@ setup_interface_offsets (MonoClass *class, int cur_slot, gboolean overwrite) * mono_class_setup_interface_offsets () passes 0 as CUR_SLOT, so the computed interface offsets will be invalid. This * means we have to overwrite those when called from other places (#4440). */ - if (class->interfaces_packed) { + if (klass->interfaces_packed) { if (!overwrite) - g_assert (class->interface_offsets_count == interface_offsets_count); + g_assert (klass->interface_offsets_count == interface_offsets_count); } else { uint8_t *bitmap; int bsize; - class->interface_offsets_count = interface_offsets_count; - class->interfaces_packed = mono_class_alloc (class, sizeof (MonoClass*) * interface_offsets_count); - class->interface_offsets_packed = mono_class_alloc (class, sizeof (guint16) * interface_offsets_count); + klass->interface_offsets_count = interface_offsets_count; + klass->interfaces_packed = (MonoClass **)mono_class_alloc (klass, sizeof (MonoClass*) * interface_offsets_count); + klass->interface_offsets_packed = (guint16 *)mono_class_alloc (klass, sizeof (guint16) * interface_offsets_count); bsize = (sizeof (guint8) * ((max_iid + 1) >> 3)) + (((max_iid + 1) & 7)? 1 :0); #ifdef COMPRESSED_INTERFACE_BITMAP bitmap = g_malloc0 (bsize); #else - bitmap = mono_class_alloc0 (class, bsize); + bitmap = (uint8_t *)mono_class_alloc0 (klass, bsize); #endif for (i = 0; i < interface_offsets_count; i++) { int id = interfaces_full [i]->interface_id; bitmap [id >> 3] |= (1 << (id & 7)); - class->interfaces_packed [i] = interfaces_full [i]; - class->interface_offsets_packed [i] = interface_offsets_full [i]; + klass->interfaces_packed [i] = interfaces_full [i]; + klass->interface_offsets_packed [i] = interface_offsets_full [i]; /*if (num_array_interfaces) - g_print ("type %s has %s offset at %d\n", mono_type_get_name_full (&class->byval_arg, 0), mono_type_get_name_full (&interfaces_full [i]->byval_arg, 0), interface_offsets_full [i]);*/ + g_print ("type %s has %s offset at %d\n", mono_type_get_name_full (&klass->byval_arg, 0), mono_type_get_name_full (&interfaces_full [i]->byval_arg, 0), interface_offsets_full [i]);*/ } #ifdef COMPRESSED_INTERFACE_BITMAP i = mono_compress_bitmap (NULL, bitmap, bsize); - class->interface_bitmap = mono_class_alloc0 (class, i); - mono_compress_bitmap (class->interface_bitmap, bitmap, bsize); + klass->interface_bitmap = mono_class_alloc0 (klass, i); + mono_compress_bitmap (klass->interface_bitmap, bitmap, bsize); g_free (bitmap); #else - class->interface_bitmap = bitmap; + klass->interface_bitmap = bitmap; #endif } @@ -3654,7 +3685,7 @@ end: g_free (interfaces_full); g_free (interface_offsets_full); g_free (array_interfaces); - for (i = 0; i < class->idepth; i++) { + for (i = 0; i < klass->idepth; i++) { ifaces = ifaces_array [i]; if (ifaces) g_ptr_array_free (ifaces, TRUE); @@ -3662,7 +3693,7 @@ end: g_free (ifaces_array); //printf ("JUST DONE: "); - //print_implemented_interfaces (class); + //print_implemented_interfaces (klass); return cur_slot; } @@ -3670,20 +3701,20 @@ end: /* * Setup interface offsets for interfaces. * Initializes: - * - class->max_interface_id - * - class->interface_offsets_count - * - class->interfaces_packed - * - class->interface_offsets_packed - * - class->interface_bitmap + * - klass->max_interface_id + * - klass->interface_offsets_count + * - klass->interfaces_packed + * - klass->interface_offsets_packed + * - klass->interface_bitmap * * This function can fail @class. */ void -mono_class_setup_interface_offsets (MonoClass *class) +mono_class_setup_interface_offsets (MonoClass *klass) { mono_loader_lock (); - setup_interface_offsets (class, 0, FALSE); + setup_interface_offsets (klass, 0, FALSE); mono_loader_unlock (); } @@ -3708,32 +3739,32 @@ mono_class_has_gtd_parent (MonoClass *klass, MonoClass *parent) } gboolean -mono_class_check_vtable_constraints (MonoClass *class, GList *in_setup) +mono_class_check_vtable_constraints (MonoClass *klass, GList *in_setup) { MonoGenericInst *ginst; int i; - if (!class->generic_class) { - mono_class_setup_vtable_full (class, in_setup); - return class->exception_type == 0; + if (!klass->generic_class) { + mono_class_setup_vtable_full (klass, in_setup); + return !mono_class_has_failure (klass); } - mono_class_setup_vtable_full (mono_class_get_generic_type_definition (class), in_setup); - if (class->generic_class->container_class->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Failed to load generic definition vtable")); + mono_class_setup_vtable_full (mono_class_get_generic_type_definition (klass), in_setup); + if (mono_class_has_failure (klass->generic_class->container_class)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Failed to load generic definition vtable")); return FALSE; } - ginst = class->generic_class->context.class_inst; + ginst = klass->generic_class->context.class_inst; for (i = 0; i < ginst->type_argc; ++i) { MonoClass *arg; if (ginst->type_argv [i]->type != MONO_TYPE_GENERICINST) continue; arg = mono_class_from_mono_type (ginst->type_argv [i]); /*Those 2 will be checked by mono_class_setup_vtable itself*/ - if (mono_class_has_gtd_parent (class, arg) || mono_class_has_gtd_parent (arg, class)) + if (mono_class_has_gtd_parent (klass, arg) || mono_class_has_gtd_parent (arg, klass)) continue; if (!mono_class_check_vtable_constraints (arg, in_setup)) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Failed to load generic parameter %d", i)); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Failed to load generic parameter %d", i)); return FALSE; } } @@ -3748,18 +3779,18 @@ mono_class_check_vtable_constraints (MonoClass *class, GList *in_setup) * - vtable * - vtable_size * Plus all the fields initialized by setup_interface_offsets (). - * If there is an error during vtable construction, class->exception_type is set. + * If there is an error during vtable construction, klass->exception_type is set. * * LOCKING: Acquires the loader lock. */ void -mono_class_setup_vtable (MonoClass *class) +mono_class_setup_vtable (MonoClass *klass) { - mono_class_setup_vtable_full (class, NULL); + mono_class_setup_vtable_full (klass, NULL); } static void -mono_class_setup_vtable_full (MonoClass *class, GList *in_setup) +mono_class_setup_vtable_full (MonoClass *klass, GList *in_setup) { MonoMethod **overrides; MonoGenericContext *context; @@ -3767,66 +3798,66 @@ mono_class_setup_vtable_full (MonoClass *class, GList *in_setup) int onum = 0; gboolean ok = TRUE; - if (class->vtable) + if (klass->vtable) return; - if (MONO_CLASS_IS_INTERFACE (class)) { + if (MONO_CLASS_IS_INTERFACE (klass)) { /* This sets method->slot for all methods if this is an interface */ - mono_class_setup_methods (class); + mono_class_setup_methods (klass); return; } - if (class->exception_type) + if (mono_class_has_failure (klass)) return; - if (g_list_find (in_setup, class)) + if (g_list_find (in_setup, klass)) return; mono_loader_lock (); - if (class->vtable) { + if (klass->vtable) { mono_loader_unlock (); return; } mono_stats.generic_vtable_count ++; - in_setup = g_list_prepend (in_setup, class); + in_setup = g_list_prepend (in_setup, klass); - if (class->generic_class) { - if (!mono_class_check_vtable_constraints (class, in_setup)) { + if (klass->generic_class) { + if (!mono_class_check_vtable_constraints (klass, in_setup)) { mono_loader_unlock (); - g_list_remove (in_setup, class); + g_list_remove (in_setup, klass); return; } - context = mono_class_get_context (class); - type_token = class->generic_class->container_class->type_token; + context = mono_class_get_context (klass); + type_token = klass->generic_class->container_class->type_token; } else { - context = (MonoGenericContext *) class->generic_container; - type_token = class->type_token; + context = (MonoGenericContext *) klass->generic_container; + type_token = klass->type_token; } - if (image_is_dynamic (class->image)) { + if (image_is_dynamic (klass->image)) { /* Generic instances can have zero method overrides without causing any harm. * This is true since we don't do layout all over again for them, we simply inflate * the layout of the parent. */ - mono_reflection_get_dynamic_overrides (class, &overrides, &onum); + mono_reflection_get_dynamic_overrides (klass, &overrides, &onum); } else { /* The following call fails if there are missing methods in the type */ /* FIXME it's probably a good idea to avoid this for generic instances. */ - ok = mono_class_get_overrides_full (class->image, type_token, &overrides, &onum, context); + ok = mono_class_get_overrides_full (klass->image, type_token, &overrides, &onum, context); } if (ok) - mono_class_setup_vtable_general (class, overrides, onum, in_setup); + mono_class_setup_vtable_general (klass, overrides, onum, in_setup); else - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Could not load list of method overrides")); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Could not load list of method overrides")); g_free (overrides); mono_loader_unlock (); - g_list_remove (in_setup, class); + g_list_remove (in_setup, klass); return; } @@ -3912,7 +3943,7 @@ is_wcf_hack_disabled (void) } static gboolean -check_interface_method_override (MonoClass *class, MonoMethod *im, MonoMethod *cm, gboolean require_newslot, gboolean interface_is_explicitly_implemented_by_class, gboolean slot_is_empty) +check_interface_method_override (MonoClass *klass, MonoMethod *im, MonoMethod *cm, gboolean require_newslot, gboolean interface_is_explicitly_implemented_by_class, gboolean slot_is_empty) { MonoMethodSignature *cmsig, *imsig; if (strcmp (im->name, cm->name) == 0) { @@ -3937,7 +3968,7 @@ check_interface_method_override (MonoClass *class, MonoMethod *im, MonoMethod *c cmsig = mono_method_signature (cm); imsig = mono_method_signature (im); if (!cmsig || !imsig) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Could not resolve the signature of a virtual method")); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Could not resolve the signature of a virtual method")); return FALSE; } @@ -3949,13 +3980,13 @@ check_interface_method_override (MonoClass *class, MonoMethod *im, MonoMethod *c } TRACE_INTERFACE_VTABLE (printf ("[SECURITY CHECKS]")); if (mono_security_core_clr_enabled ()) - mono_security_core_clr_check_override (class, cm, im); + mono_security_core_clr_check_override (klass, cm, im); TRACE_INTERFACE_VTABLE (printf ("[NAME CHECK OK]")); if (is_wcf_hack_disabled () && !mono_method_can_access_method_full (cm, im, NULL)) { char *body_name = mono_method_full_name (cm, TRUE); char *decl_name = mono_method_full_name (im, TRUE); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Method %s overrides method '%s' which is not accessible", body_name, decl_name)); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Method %s overrides method '%s' which is not accessible", body_name, decl_name)); g_free (body_name); g_free (decl_name); return FALSE; @@ -3979,7 +4010,7 @@ check_interface_method_override (MonoClass *class, MonoMethod *im, MonoMethod *c cmsig = mono_method_signature (cm); imsig = mono_method_signature (im); if (!cmsig || !imsig) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Could not resolve the signature of a virtual method")); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Could not resolve the signature of a virtual method")); return FALSE; } @@ -4030,13 +4061,13 @@ check_interface_method_override (MonoClass *class, MonoMethod *im, MonoMethod *c TRACE_INTERFACE_VTABLE (printf ("[SECURITY CHECKS (INJECTED CASE)]")); if (mono_security_core_clr_enabled ()) - mono_security_core_clr_check_override (class, cm, im); + mono_security_core_clr_check_override (klass, cm, im); TRACE_INTERFACE_VTABLE (printf ("[INJECTED INTERFACE CHECK OK]")); if (is_wcf_hack_disabled () && !mono_method_can_access_method_full (cm, im, NULL)) { char *body_name = mono_method_full_name (cm, TRUE); char *decl_name = mono_method_full_name (im, TRUE); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Method %s overrides method '%s' which is not accessible", body_name, decl_name)); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Method %s overrides method '%s' which is not accessible", body_name, decl_name)); g_free (body_name); g_free (decl_name); return FALSE; @@ -4069,20 +4100,20 @@ print_overrides (GHashTable *override_map, const char *message) { } } static void -print_vtable_full (MonoClass *class, MonoMethod** vtable, int size, int first_non_interface_slot, const char *message, gboolean print_interfaces) { - char *full_name = mono_type_full_name (&class->byval_arg); +print_vtable_full (MonoClass *klass, MonoMethod** vtable, int size, int first_non_interface_slot, const char *message, gboolean print_interfaces) { + char *full_name = mono_type_full_name (&klass->byval_arg); int i; int parent_size; printf ("*** Vtable for class '%s' at \"%s\" (size %d)\n", full_name, message, size); if (print_interfaces) { - print_implemented_interfaces (class); + print_implemented_interfaces (klass); printf ("* Interfaces for class '%s' done.\nStarting vtable (size %d):\n", full_name, size); } - if (class->parent) { - parent_size = class->parent->vtable_size; + if (klass->parent) { + parent_size = klass->parent->vtable_size; } else { parent_size = 0; } @@ -4112,20 +4143,20 @@ mono_method_try_get_vtable_index (MonoMethod *method) } static void -mono_class_verify_vtable (MonoClass *class) +mono_class_verify_vtable (MonoClass *klass) { int i; - char *full_name = mono_type_full_name (&class->byval_arg); + char *full_name = mono_type_full_name (&klass->byval_arg); printf ("*** Verifying VTable of class '%s' \n", full_name); g_free (full_name); full_name = NULL; - if (!class->methods) + if (!klass->methods) return; - for (i = 0; i < class->method.count; ++i) { - MonoMethod *cm = class->methods [i]; + for (i = 0; i < klass->method.count; ++i) { + MonoMethod *cm = klass->methods [i]; int slot; if (!(cm->flags & METHOD_ATTRIBUTE_VIRTUAL)) @@ -4136,13 +4167,13 @@ mono_class_verify_vtable (MonoClass *class) slot = mono_method_try_get_vtable_index (cm); if (slot >= 0) { - if (slot >= class->vtable_size) { - printf ("\tInvalid method %s at index %d with vtable of length %d\n", full_name, slot, class->vtable_size); + if (slot >= klass->vtable_size) { + printf ("\tInvalid method %s at index %d with vtable of length %d\n", full_name, slot, klass->vtable_size); continue; } - if (slot >= 0 && class->vtable [slot] != cm && (class->vtable [slot])) { - char *other_name = class->vtable [slot] ? mono_method_full_name (class->vtable [slot], TRUE) : g_strdup ("[null value]"); + if (slot >= 0 && klass->vtable [slot] != cm && (klass->vtable [slot])) { + char *other_name = klass->vtable [slot] ? mono_method_full_name (klass->vtable [slot], TRUE) : g_strdup ("[null value]"); printf ("\tMethod %s has slot %d but vtable has %s on it\n", full_name, slot, other_name); g_free (other_name); } @@ -4154,7 +4185,7 @@ mono_class_verify_vtable (MonoClass *class) #endif static void -print_unimplemented_interface_method_info (MonoClass *class, MonoClass *ic, MonoMethod *im, int im_slot, MonoMethod **overrides, int onum) { +print_unimplemented_interface_method_info (MonoClass *klass, MonoClass *ic, MonoMethod *im, int im_slot, MonoMethod **overrides, int onum) { int index; char *method_signature; char *type_name; @@ -4164,20 +4195,20 @@ print_unimplemented_interface_method_info (MonoClass *class, MonoClass *ic, Mono overrides [index*2+1]->slot, overrides [index*2]->name, overrides [index*2]->slot); } method_signature = mono_signature_get_desc (mono_method_signature (im), FALSE); - type_name = mono_type_full_name (&class->byval_arg); + type_name = mono_type_full_name (&klass->byval_arg); mono_trace_warning (MONO_TRACE_TYPE, "no implementation for interface method %s::%s(%s) in class %s\n", mono_type_get_name (&ic->byval_arg), im->name, method_signature, type_name); g_free (method_signature); g_free (type_name); - mono_class_setup_methods (class); - if (class->exception_type) { - char *name = mono_type_get_full_name (class); + mono_class_setup_methods (klass); + if (mono_class_has_failure (klass)) { + char *name = mono_type_get_full_name (klass); mono_trace_warning (MONO_TRACE_TYPE, "CLASS %s failed to resolve methods\n", name); g_free (name); return; } - for (index = 0; index < class->method.count; ++index) { - MonoMethod *cm = class->methods [index]; + for (index = 0; index < klass->method.count; ++index) { + MonoMethod *cm = klass->methods [index]; method_signature = mono_signature_get_desc (mono_method_signature (cm), TRUE); mono_trace_warning (MONO_TRACE_TYPE, "METHOD %s(%s)\n", cm->name, method_signature); @@ -4194,7 +4225,7 @@ mono_method_get_method_definition (MonoMethod *method) } static gboolean -verify_class_overrides (MonoClass *class, MonoMethod **overrides, int onum) +verify_class_overrides (MonoClass *klass, MonoMethod **overrides, int onum) { int i; @@ -4202,29 +4233,29 @@ verify_class_overrides (MonoClass *class, MonoMethod **overrides, int onum) MonoMethod *decl = overrides [i * 2]; MonoMethod *body = overrides [i * 2 + 1]; - if (mono_class_get_generic_type_definition (body->klass) != mono_class_get_generic_type_definition (class)) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method belongs to a different class than the declared one")); + if (mono_class_get_generic_type_definition (body->klass) != mono_class_get_generic_type_definition (klass)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method belongs to a different class than the declared one")); return FALSE; } if (!(body->flags & METHOD_ATTRIBUTE_VIRTUAL) || (body->flags & METHOD_ATTRIBUTE_STATIC)) { if (body->flags & METHOD_ATTRIBUTE_STATIC) - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method must not be static to override a base type")); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method must not be static to override a base type")); else - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method must be virtual to override a base type")); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method must be virtual to override a base type")); return FALSE; } if (!(decl->flags & METHOD_ATTRIBUTE_VIRTUAL) || (decl->flags & METHOD_ATTRIBUTE_STATIC)) { if (body->flags & METHOD_ATTRIBUTE_STATIC) - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Cannot override a static method in a base type")); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Cannot override a static method in a base type")); else - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Cannot override a non virtual method in a base type")); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Cannot override a non virtual method in a base type")); return FALSE; } - if (!mono_class_is_assignable_from_slow (decl->klass, class)) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method overrides a class or interface that extended or implemented by this type")); + if (!mono_class_is_assignable_from_slow (decl->klass, klass)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Method overrides a class or interface that is not extended or implemented by this type")); return FALSE; } @@ -4234,7 +4265,7 @@ verify_class_overrides (MonoClass *class, MonoMethod **overrides, int onum) if (is_wcf_hack_disabled () && !mono_method_can_access_method_full (body, decl, NULL)) { char *body_name = mono_method_full_name (body, TRUE); char *decl_name = mono_method_full_name (decl, TRUE); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Method %s overrides method '%s' which is not accessible", body_name, decl_name)); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Method %s overrides method '%s' which is not accessible", body_name, decl_name)); g_free (body_name); g_free (decl_name); return FALSE; @@ -4244,16 +4275,16 @@ verify_class_overrides (MonoClass *class, MonoMethod **overrides, int onum) } static gboolean -mono_class_need_stelemref_method (MonoClass *class) +mono_class_need_stelemref_method (MonoClass *klass) { - return class->rank == 1 && MONO_TYPE_IS_REFERENCE (&class->element_class->byval_arg); + return klass->rank == 1 && MONO_TYPE_IS_REFERENCE (&klass->element_class->byval_arg); } /* * LOCKING: this is supposed to be called with the loader lock held. */ void -mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int onum, GList *in_setup) +mono_class_setup_vtable_general (MonoClass *klass, MonoMethod **overrides, int onum, GList *in_setup) { MonoError error; MonoClass *k, *ic; @@ -4268,84 +4299,84 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o GSList *virt_methods = NULL, *l; int stelemref_slot = 0; - if (class->vtable) + if (klass->vtable) return; - if (overrides && !verify_class_overrides (class, overrides, onum)) + if (overrides && !verify_class_overrides (klass, overrides, onum)) return; - ifaces = mono_class_get_implemented_interfaces (class, &error); + ifaces = mono_class_get_implemented_interfaces (klass, &error); if (!mono_error_ok (&error)) { - char *name = mono_type_get_full_name (class); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Could not resolve %s interfaces due to %s", name, mono_error_get_message (&error))); + char *name = mono_type_get_full_name (klass); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Could not resolve %s interfaces due to %s", name, mono_error_get_message (&error))); g_free (name); mono_error_cleanup (&error); return; } else if (ifaces) { for (i = 0; i < ifaces->len; i++) { - MonoClass *ic = g_ptr_array_index (ifaces, i); + MonoClass *ic = (MonoClass *)g_ptr_array_index (ifaces, i); max_vtsize += ic->method.count; } g_ptr_array_free (ifaces, TRUE); ifaces = NULL; } - if (class->parent) { - mono_class_init (class->parent); - mono_class_setup_vtable_full (class->parent, in_setup); + if (klass->parent) { + mono_class_init (klass->parent); + mono_class_setup_vtable_full (klass->parent, in_setup); - if (class->parent->exception_type) { - char *name = mono_type_get_full_name (class->parent); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Parent %s failed to load", name)); + if (mono_class_has_failure (klass->parent)) { + char *name = mono_type_get_full_name (klass->parent); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Parent %s failed to load", name)); g_free (name); return; } - max_vtsize += class->parent->vtable_size; - cur_slot = class->parent->vtable_size; + max_vtsize += klass->parent->vtable_size; + cur_slot = klass->parent->vtable_size; } - max_vtsize += class->method.count; + max_vtsize += klass->method.count; /*Array have a slot for stelemref*/ - if (mono_class_need_stelemref_method (class)) { + if (mono_class_need_stelemref_method (klass)) { stelemref_slot = cur_slot; ++max_vtsize; ++cur_slot; } - vtable = alloca (sizeof (gpointer) * max_vtsize); + vtable = (MonoMethod **)alloca (sizeof (gpointer) * max_vtsize); memset (vtable, 0, sizeof (gpointer) * max_vtsize); - /* printf ("METAINIT %s.%s\n", class->name_space, class->name); */ + /* printf ("METAINIT %s.%s\n", klass->name_space, klass->name); */ - cur_slot = setup_interface_offsets (class, cur_slot, TRUE); + cur_slot = setup_interface_offsets (klass, cur_slot, TRUE); if (cur_slot == -1) /*setup_interface_offsets fails the type.*/ return; - max_iid = class->max_interface_id; + max_iid = klass->max_interface_id; DEBUG_INTERFACE_VTABLE (first_non_interface_slot = cur_slot); /* Optimized version for generic instances */ - if (class->generic_class) { + if (klass->generic_class) { MonoError error; - MonoClass *gklass = class->generic_class->container_class; + MonoClass *gklass = klass->generic_class->container_class; MonoMethod **tmp; mono_class_setup_vtable_full (gklass, in_setup); - if (gklass->exception_type != MONO_EXCEPTION_NONE) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + if (mono_class_has_failure (gklass)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); return; } - tmp = mono_class_alloc0 (class, sizeof (gpointer) * gklass->vtable_size); - class->vtable_size = gklass->vtable_size; + tmp = (MonoMethod **)mono_class_alloc0 (klass, sizeof (gpointer) * gklass->vtable_size); + klass->vtable_size = gklass->vtable_size; for (i = 0; i < gklass->vtable_size; ++i) if (gklass->vtable [i]) { - MonoMethod *inflated = mono_class_inflate_generic_method_full_checked (gklass->vtable [i], class, mono_class_get_context (class), &error); + MonoMethod *inflated = mono_class_inflate_generic_method_full_checked (gklass->vtable [i], klass, mono_class_get_context (klass), &error); if (!mono_error_ok (&error)) { char *err_msg = g_strdup_printf ("Could not inflate method due to %s", mono_error_get_message (&error)); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, err_msg); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg); g_free (err_msg); mono_error_cleanup (&error); return; @@ -4354,20 +4385,20 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o tmp [i]->slot = gklass->vtable [i]->slot; } mono_memory_barrier (); - class->vtable = tmp; + klass->vtable = tmp; /* Have to set method->slot for abstract virtual methods */ - if (class->methods && gklass->methods) { - for (i = 0; i < class->method.count; ++i) - if (class->methods [i]->slot == -1) - class->methods [i]->slot = gklass->methods [i]->slot; + if (klass->methods && gklass->methods) { + for (i = 0; i < klass->method.count; ++i) + if (klass->methods [i]->slot == -1) + klass->methods [i]->slot = gklass->methods [i]->slot; } return; } - if (class->parent && class->parent->vtable_size) { - MonoClass *parent = class->parent; + if (klass->parent && klass->parent->vtable_size) { + MonoClass *parent = klass->parent; int i; memcpy (vtable, parent->vtable, sizeof (gpointer) * parent->vtable_size); @@ -4378,7 +4409,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o // classes the ".override" information is not used anymore. for (i = 0; i < parent->interface_offsets_count; i++) { MonoClass *parent_interface = parent->interfaces_packed [i]; - int interface_offset = mono_class_interface_offset (class, parent_interface); + int interface_offset = mono_class_interface_offset (klass, parent_interface); /*FIXME this is now dead code as this condition will never hold true. Since interface offsets are inherited then the offset of an interface implemented by a parent will never be the out of it's vtable boundary. @@ -4389,7 +4420,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o mono_class_setup_methods (parent_interface); /*FIXME Just kill this whole chunk of dead code*/ TRACE_INTERFACE_VTABLE (printf (" +++ Inheriting interface %s.%s\n", parent_interface->name_space, parent_interface->name)); - for (j = 0; j < parent_interface->method.count && !class->exception_type; j++) { + for (j = 0; j < parent_interface->method.count && !mono_class_has_failure (klass); j++) { vtable [interface_offset + j] = parent->vtable [parent_interface_offset + j]; TRACE_INTERFACE_VTABLE (printf (" --- Inheriting: [%03d][(%03d)+(%03d)] => [%03d][(%03d)+(%03d)]\n", parent_interface_offset + j, parent_interface_offset, j, @@ -4401,8 +4432,8 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o } /*Array have a slot for stelemref*/ - if (mono_class_need_stelemref_method (class)) { - MonoMethod *method = mono_marshal_get_virtual_stelemref (class); + if (mono_class_need_stelemref_method (klass)) { + MonoMethod *method = mono_marshal_get_virtual_stelemref (klass); if (!method->slot) method->slot = stelemref_slot; else @@ -4411,7 +4442,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o vtable [stelemref_slot] = method; } - TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER INHERITING PARENT VTABLE", TRUE)); + TRACE_INTERFACE_VTABLE (print_vtable_full (klass, vtable, cur_slot, first_non_interface_slot, "AFTER INHERITING PARENT VTABLE", TRUE)); /* override interface methods */ for (i = 0; i < onum; i++) { MonoMethod *decl = overrides [i*2]; @@ -4419,11 +4450,11 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o int dslot; dslot = mono_method_get_vtable_slot (decl); if (dslot == -1) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); return; } - dslot += mono_class_interface_offset (class, decl->klass); + dslot += mono_class_interface_offset (klass, decl->klass); vtable [dslot] = overrides [i*2 + 1]; vtable [dslot]->slot = dslot; if (!override_map) @@ -4432,11 +4463,11 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o g_hash_table_insert (override_map, overrides [i * 2], overrides [i * 2 + 1]); if (mono_security_core_clr_enabled ()) - mono_security_core_clr_check_override (class, vtable [dslot], decl); + mono_security_core_clr_check_override (klass, vtable [dslot], decl); } } TRACE_INTERFACE_VTABLE (print_overrides (override_map, "AFTER OVERRIDING INTERFACE METHODS")); - TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER OVERRIDING INTERFACE METHODS", FALSE)); + TRACE_INTERFACE_VTABLE (print_vtable_full (klass, vtable, cur_slot, first_non_interface_slot, "AFTER OVERRIDING INTERFACE METHODS", FALSE)); /* * Create a list of virtual methods to avoid calling @@ -4448,33 +4479,33 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o MonoMethod *cm; virt_methods = NULL; - while ((cm = mono_class_get_virtual_methods (class, &iter))) { + while ((cm = mono_class_get_virtual_methods (klass, &iter))) { virt_methods = g_slist_prepend (virt_methods, cm); } - if (class->exception_type) + if (mono_class_has_failure (klass)) goto fail; } // Loop on all implemented interfaces... - for (i = 0; i < class->interface_offsets_count; i++) { - MonoClass *parent = class->parent; + for (i = 0; i < klass->interface_offsets_count; i++) { + MonoClass *parent = klass->parent; int ic_offset; gboolean interface_is_explicitly_implemented_by_class; int im_index; - ic = class->interfaces_packed [i]; - ic_offset = mono_class_interface_offset (class, ic); + ic = klass->interfaces_packed [i]; + ic_offset = mono_class_interface_offset (klass, ic); mono_class_setup_methods (ic); - if (ic->exception_type) + if (mono_class_has_failure (ic)) goto fail; // Check if this interface is explicitly implemented (instead of just inherited) if (parent != NULL) { int implemented_interfaces_index; interface_is_explicitly_implemented_by_class = FALSE; - for (implemented_interfaces_index = 0; implemented_interfaces_index < class->interface_count; implemented_interfaces_index++) { - if (ic == class->interfaces [implemented_interfaces_index]) { + for (implemented_interfaces_index = 0; implemented_interfaces_index < klass->interface_count; implemented_interfaces_index++) { + if (ic == klass->interfaces [implemented_interfaces_index]) { interface_is_explicitly_implemented_by_class = TRUE; break; } @@ -4487,7 +4518,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o for (im_index = 0; im_index < ic->method.count; im_index++) { MonoMethod *im = ic->methods [im_index]; int im_slot = ic_offset + im->slot; - MonoMethod *override_im = (override_map != NULL) ? g_hash_table_lookup (override_map, im) : NULL; + MonoMethod *override_im = (override_map != NULL) ? (MonoMethod *)g_hash_table_lookup (override_map, im) : NULL; if (im->flags & METHOD_ATTRIBUTE_STATIC) continue; @@ -4502,9 +4533,9 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o // First look for a suitable method among the class methods for (l = virt_methods; l; l = l->next) { - cm = l->data; + cm = (MonoMethod *)l->data; TRACE_INTERFACE_VTABLE (printf (" For slot %d ('%s'.'%s':'%s'), trying method '%s'.'%s':'%s'... [EXPLICIT IMPLEMENTATION = %d][SLOT IS NULL = %d]", im_slot, ic->name_space, ic->name, im->name, cm->klass->name_space, cm->klass->name, cm->name, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL))); - if (check_interface_method_override (class, im, cm, TRUE, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL))) { + if (check_interface_method_override (klass, im, cm, TRUE, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL))) { TRACE_INTERFACE_VTABLE (printf ("[check ok]: ASSIGNING")); vtable [im_slot] = cm; /* Why do we need this? */ @@ -4513,19 +4544,19 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o } } TRACE_INTERFACE_VTABLE (printf ("\n")); - if (class->exception_type) /*Might be set by check_interface_method_override*/ + if (mono_class_has_failure (klass)) /*Might be set by check_interface_method_override*/ goto fail; } // If the slot is still empty, look in all the inherited virtual methods... - if ((vtable [im_slot] == NULL) && class->parent != NULL) { - MonoClass *parent = class->parent; + if ((vtable [im_slot] == NULL) && klass->parent != NULL) { + MonoClass *parent = klass->parent; // Reverse order, so that last added methods are preferred for (cm_index = parent->vtable_size - 1; cm_index >= 0; cm_index--) { MonoMethod *cm = parent->vtable [cm_index]; TRACE_INTERFACE_VTABLE ((cm != NULL) && printf (" For slot %d ('%s'.'%s':'%s'), trying (ancestor) method '%s'.'%s':'%s'... ", im_slot, ic->name_space, ic->name, im->name, cm->klass->name_space, cm->klass->name, cm->name)); - if ((cm != NULL) && check_interface_method_override (class, im, cm, FALSE, FALSE, TRUE)) { + if ((cm != NULL) && check_interface_method_override (klass, im, cm, FALSE, FALSE, TRUE)) { TRACE_INTERFACE_VTABLE (printf ("[everything ok]: ASSIGNING")); vtable [im_slot] = cm; /* Why do we need this? */ @@ -4534,7 +4565,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o } break; } - if (class->exception_type) /*Might be set by check_interface_method_override*/ + if (mono_class_has_failure (klass)) /*Might be set by check_interface_method_override*/ goto fail; TRACE_INTERFACE_VTABLE ((cm != NULL) && printf ("\n")); } @@ -4550,13 +4581,13 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o // it can happen (for injected generic array interfaces) that the same slot is // processed multiple times (those interfaces have overlapping slots), and it // will not always be the first pass the one that fills the slot. - if (! (class->flags & TYPE_ATTRIBUTE_ABSTRACT)) { - for (i = 0; i < class->interface_offsets_count; i++) { + if (! (klass->flags & TYPE_ATTRIBUTE_ABSTRACT)) { + for (i = 0; i < klass->interface_offsets_count; i++) { int ic_offset; int im_index; - ic = class->interfaces_packed [i]; - ic_offset = mono_class_interface_offset (class, ic); + ic = klass->interfaces_packed [i]; + ic_offset = mono_class_interface_offset (klass, ic); for (im_index = 0; im_index < ic->method.count; im_index++) { MonoMethod *im = ic->methods [im_index]; @@ -4568,23 +4599,23 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o TRACE_INTERFACE_VTABLE (printf (" [class is not abstract, checking slot %d for interface '%s'.'%s', method %s, slot check is %d]\n", im_slot, ic->name_space, ic->name, im->name, (vtable [im_slot] == NULL))); if (vtable [im_slot] == NULL) { - print_unimplemented_interface_method_info (class, ic, im, im_slot, overrides, onum); + print_unimplemented_interface_method_info (klass, ic, im, im_slot, overrides, onum); goto fail; } } } } - TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER SETTING UP INTERFACE METHODS", FALSE)); + TRACE_INTERFACE_VTABLE (print_vtable_full (klass, vtable, cur_slot, first_non_interface_slot, "AFTER SETTING UP INTERFACE METHODS", FALSE)); for (l = virt_methods; l; l = l->next) { - cm = l->data; + cm = (MonoMethod *)l->data; /* * If the method is REUSE_SLOT, we must check in the * base class for a method to override. */ if (!(cm->flags & METHOD_ATTRIBUTE_NEW_SLOT)) { int slot = -1; - for (k = class->parent; k ; k = k->parent) { + for (k = klass->parent; k ; k = k->parent) { gpointer k_iter; MonoMethod *m1; @@ -4596,7 +4627,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o m1sig = mono_method_signature (m1); if (!cmsig || !m1sig) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); return; } @@ -4604,7 +4635,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o mono_metadata_signature_equal (cmsig, m1sig)) { if (mono_security_core_clr_enabled ()) - mono_security_core_clr_check_override (class, cm, m1); + mono_security_core_clr_check_override (klass, cm, m1); slot = mono_method_get_vtable_slot (m1); if (slot == -1) @@ -4613,7 +4644,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o if (is_wcf_hack_disabled () && !mono_method_can_access_method_full (cm, m1, NULL)) { char *body_name = mono_method_full_name (cm, TRUE); char *decl_name = mono_method_full_name (m1, TRUE); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Method %s overrides method '%s' which is not accessible", body_name, decl_name)); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Method %s overrides method '%s' which is not accessible", body_name, decl_name)); g_free (body_name); g_free (decl_name); goto fail; @@ -4629,7 +4660,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o break; } } - if (k->exception_type) + if (mono_class_has_failure (k)) goto fail; if (slot >= 0) @@ -4665,7 +4696,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o g_hash_table_insert (override_map, decl, overrides [i * 2 + 1]); if (mono_security_core_clr_enabled ()) - mono_security_core_clr_check_override (class, vtable [decl->slot], decl); + mono_security_core_clr_check_override (klass, vtable [decl->slot], decl); } } @@ -4680,7 +4711,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o if (vtable [i]) { TRACE_INTERFACE_VTABLE (printf ("checking slot %d method %s[%p] for overrides\n", i, mono_method_full_name (vtable [i], 1), vtable [i])); - cm = g_hash_table_lookup (override_map, vtable [i]); + cm = (MonoMethod *)g_hash_table_lookup (override_map, vtable [i]); if (cm) vtable [i] = cm; } @@ -4693,12 +4724,12 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o virt_methods = NULL; /* Ensure that all vtable slots are filled with concrete instance methods */ - if (!(class->flags & TYPE_ATTRIBUTE_ABSTRACT)) { + if (!(klass->flags & TYPE_ATTRIBUTE_ABSTRACT)) { for (i = 0; i < cur_slot; ++i) { if (vtable [i] == NULL || (vtable [i]->flags & (METHOD_ATTRIBUTE_ABSTRACT | METHOD_ATTRIBUTE_STATIC))) { - char *type_name = mono_type_get_full_name (class); + char *type_name = mono_type_get_full_name (klass); char *method_name = vtable [i] ? mono_method_full_name (vtable [i], TRUE) : g_strdup ("none"); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Type %s has invalid vtable method slot %d with method %s", type_name, i, method_name)); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Type %s has invalid vtable method slot %d with method %s", type_name, i, method_name)); g_free (type_name); g_free (method_name); return; @@ -4706,42 +4737,42 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o } } - if (class->generic_class) { - MonoClass *gklass = class->generic_class->container_class; + if (klass->generic_class) { + MonoClass *gklass = klass->generic_class->container_class; mono_class_init (gklass); - class->vtable_size = MAX (gklass->vtable_size, cur_slot); + klass->vtable_size = MAX (gklass->vtable_size, cur_slot); } else { /* Check that the vtable_size value computed in mono_class_init () is correct */ - if (class->vtable_size) - g_assert (cur_slot == class->vtable_size); - class->vtable_size = cur_slot; + if (klass->vtable_size) + g_assert (cur_slot == klass->vtable_size); + klass->vtable_size = cur_slot; } /* Try to share the vtable with our parent. */ - if (class->parent && (class->parent->vtable_size == class->vtable_size) && (memcmp (class->parent->vtable, vtable, sizeof (gpointer) * class->vtable_size) == 0)) { + if (klass->parent && (klass->parent->vtable_size == klass->vtable_size) && (memcmp (klass->parent->vtable, vtable, sizeof (gpointer) * klass->vtable_size) == 0)) { mono_memory_barrier (); - class->vtable = class->parent->vtable; + klass->vtable = klass->parent->vtable; } else { - MonoMethod **tmp = mono_class_alloc0 (class, sizeof (gpointer) * class->vtable_size); - memcpy (tmp, vtable, sizeof (gpointer) * class->vtable_size); + MonoMethod **tmp = (MonoMethod **)mono_class_alloc0 (klass, sizeof (gpointer) * klass->vtable_size); + memcpy (tmp, vtable, sizeof (gpointer) * klass->vtable_size); mono_memory_barrier (); - class->vtable = tmp; + klass->vtable = tmp; } - DEBUG_INTERFACE_VTABLE (print_vtable_full (class, class->vtable, class->vtable_size, first_non_interface_slot, "FINALLY", FALSE)); + DEBUG_INTERFACE_VTABLE (print_vtable_full (klass, klass->vtable, klass->vtable_size, first_non_interface_slot, "FINALLY", FALSE)); if (mono_print_vtable) { int icount = 0; - print_implemented_interfaces (class); + print_implemented_interfaces (klass); for (i = 0; i <= max_iid; i++) - if (MONO_CLASS_IMPLEMENTS_INTERFACE (class, i)) + if (MONO_CLASS_IMPLEMENTS_INTERFACE (klass, i)) icount++; - printf ("VTable %s (vtable entries = %d, interfaces = %d)\n", mono_type_full_name (&class->byval_arg), - class->vtable_size, icount); + printf ("VTable %s (vtable entries = %d, interfaces = %d)\n", mono_type_full_name (&klass->byval_arg), + klass->vtable_size, icount); for (i = 0; i < cur_slot; ++i) { MonoMethod *cm; @@ -4755,34 +4786,34 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o if (icount) { - printf ("Interfaces %s.%s (max_iid = %d)\n", class->name_space, - class->name, max_iid); + printf ("Interfaces %s.%s (max_iid = %d)\n", klass->name_space, + klass->name, max_iid); - for (i = 0; i < class->interface_count; i++) { - ic = class->interfaces [i]; + for (i = 0; i < klass->interface_count; i++) { + ic = klass->interfaces [i]; printf (" slot offset: %03d, method count: %03d, iid: %03d %s\n", - mono_class_interface_offset (class, ic), + mono_class_interface_offset (klass, ic), count_virtual_methods (ic), ic->interface_id, mono_type_full_name (&ic->byval_arg)); } - for (k = class->parent; k ; k = k->parent) { + for (k = klass->parent; k ; k = k->parent) { for (i = 0; i < k->interface_count; i++) { ic = k->interfaces [i]; printf (" parent slot offset: %03d, method count: %03d, iid: %03d %s\n", - mono_class_interface_offset (class, ic), + mono_class_interface_offset (klass, ic), count_virtual_methods (ic), ic->interface_id, mono_type_full_name (&ic->byval_arg)); } } } } - VERIFY_INTERFACE_VTABLE (mono_class_verify_vtable (class)); + VERIFY_INTERFACE_VTABLE (mono_class_verify_vtable (klass)); return; fail: { - char *name = mono_type_get_full_name (class); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("VTable setup of type %s failed", name)); + char *name = mono_type_get_full_name (klass); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("VTable setup of type %s failed", name)); g_free (name); if (override_map) g_hash_table_destroy (override_map); @@ -4804,7 +4835,7 @@ mono_method_get_vtable_slot (MonoMethod *method) { if (method->slot == -1) { mono_class_setup_vtable (method->klass); - if (method->klass->exception_type) + if (mono_class_has_failure (method->klass)) return -1; if (method->slot == -1) { MonoClass *gklass; @@ -4860,15 +4891,15 @@ static int finalize_slot = -1; static int ghc_slot = -1; static void -initialize_object_slots (MonoClass *class) +initialize_object_slots (MonoClass *klass) { int i; if (default_ghc) return; - if (class == mono_defaults.object_class) { - mono_class_setup_vtable (class); - for (i = 0; i < class->vtable_size; ++i) { - MonoMethod *cm = class->vtable [i]; + if (klass == mono_defaults.object_class) { + mono_class_setup_vtable (klass); + for (i = 0; i < klass->vtable_size; ++i) { + MonoMethod *cm = klass->vtable [i]; if (!strcmp (cm->name, "GetHashCode")) ghc_slot = i; @@ -4877,10 +4908,10 @@ initialize_object_slots (MonoClass *class) } g_assert (ghc_slot > 0); - default_ghc = class->vtable [ghc_slot]; + default_ghc = klass->vtable [ghc_slot]; g_assert (finalize_slot > 0); - default_finalize = class->vtable [finalize_slot]; + default_finalize = klass->vtable [finalize_slot]; } } @@ -4893,28 +4924,28 @@ static int generic_array_method_num = 0; static GenericArrayMethodInfo *generic_array_method_info = NULL; static int -generic_array_methods (MonoClass *class) +generic_array_methods (MonoClass *klass) { int i, count_generic = 0; GList *list = NULL, *tmp; if (generic_array_method_num) return generic_array_method_num; - mono_class_setup_methods (class->parent); /*This is setting up System.Array*/ - g_assert (!class->parent->exception_type); /*So hitting this assert is a huge problem*/ - for (i = 0; i < class->parent->method.count; i++) { - MonoMethod *m = class->parent->methods [i]; + mono_class_setup_methods (klass->parent); /*This is setting up System.Array*/ + g_assert (!mono_class_has_failure (klass->parent)); /*So hitting this assert is a huge problem*/ + for (i = 0; i < klass->parent->method.count; i++) { + MonoMethod *m = klass->parent->methods [i]; if (!strncmp (m->name, "InternalArray__", 15)) { count_generic++; list = g_list_prepend (list, m); } } list = g_list_reverse (list); - generic_array_method_info = mono_image_alloc (mono_defaults.corlib, sizeof (GenericArrayMethodInfo) * count_generic); + generic_array_method_info = (GenericArrayMethodInfo *)mono_image_alloc (mono_defaults.corlib, sizeof (GenericArrayMethodInfo) * count_generic); i = 0; for (tmp = list; tmp; tmp = tmp->next) { const char *mname, *iname; gchar *name; - MonoMethod *m = tmp->data; + MonoMethod *m = (MonoMethod *)tmp->data; const char *ireadonlylist_prefix = "InternalArray__IReadOnlyList_"; const char *ireadonlycollection_prefix = "InternalArray__IReadOnlyCollection_"; @@ -4938,7 +4969,7 @@ generic_array_methods (MonoClass *class) g_assert_not_reached (); } - name = mono_image_alloc (mono_defaults.corlib, strlen (iname) + strlen (mname) + 1); + name = (gchar *)mono_image_alloc (mono_defaults.corlib, strlen (iname) + strlen (mname) + 1); strcpy (name, iname); strcpy (name + strlen (iname), mname); generic_array_method_info [i].name = name; @@ -4952,7 +4983,7 @@ generic_array_methods (MonoClass *class) } static void -setup_generic_array_ifaces (MonoClass *class, MonoClass *iface, MonoMethod **methods, int pos) +setup_generic_array_ifaces (MonoClass *klass, MonoClass *iface, MonoMethod **methods, int pos) { MonoGenericContext tmp_context; int i; @@ -4968,7 +4999,7 @@ setup_generic_array_ifaces (MonoClass *class, MonoClass *iface, MonoMethod **met inflated = mono_class_inflate_generic_method_checked (m, &tmp_context, &error); g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/ - methods [pos++] = mono_marshal_get_generic_array_helper (class, iface, generic_array_method_info [i].name, inflated); + methods [pos++] = mono_marshal_get_generic_array_helper (klass, iface, generic_array_method_info [i].name, inflated); } } @@ -4977,7 +5008,7 @@ concat_two_strings_with_zero (MonoImage *image, const char *s1, const char *s2) { int null_length = strlen ("(null)"); int len = (s1 ? strlen (s1) : null_length) + (s2 ? strlen (s2) : null_length) + 2; - char *s = mono_image_alloc (image, len); + char *s = (char *)mono_image_alloc (image, len); int result; result = g_snprintf (s, len, "%s%c%s", s1 ? s1 : "(null)", '\0', s2 ? s2 : "(null)"); @@ -4987,17 +5018,17 @@ concat_two_strings_with_zero (MonoImage *image, const char *s1, const char *s2) } static void -set_failure_from_loader_error (MonoClass *class, MonoLoaderError *error) +set_failure_from_loader_error (MonoClass *klass, MonoLoaderError *error) { gpointer exception_data = NULL; switch (error->exception_type) { case MONO_EXCEPTION_TYPE_LOAD: - exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->assembly_name); + exception_data = concat_two_strings_with_zero (klass->image, error->class_name, error->assembly_name); break; case MONO_EXCEPTION_MISSING_METHOD: - exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->member_name); + exception_data = concat_two_strings_with_zero (klass->image, error->class_name, error->member_name); break; case MONO_EXCEPTION_MISSING_FIELD: { @@ -5009,7 +5040,7 @@ set_failure_from_loader_error (MonoClass *class, MonoLoaderError *error) else class_name = error->klass->name; - exception_data = concat_two_strings_with_zero (class->image, class_name, error->member_name); + exception_data = concat_two_strings_with_zero (klass->image, class_name, error->member_name); if (name_space) g_free ((void*)class_name); @@ -5024,7 +5055,7 @@ set_failure_from_loader_error (MonoClass *class, MonoLoaderError *error) else msg = "Could not load file or assembly '%s' or one of its dependencies."; - exception_data = concat_two_strings_with_zero (class->image, msg, error->assembly_name); + exception_data = concat_two_strings_with_zero (klass->image, msg, error->assembly_name); break; } @@ -5036,7 +5067,7 @@ set_failure_from_loader_error (MonoClass *class, MonoLoaderError *error) g_assert_not_reached (); } - mono_class_set_failure (class, error->exception_type, exception_data); + mono_class_set_failure (klass, error->exception_type, exception_data); } /** @@ -5051,117 +5082,117 @@ set_failure_from_loader_error (MonoClass *class, MonoLoaderError *error) * LOCKING: Acquires the loader lock. */ gboolean -mono_class_init (MonoClass *class) +mono_class_init (MonoClass *klass) { int i; MonoCachedClassInfo cached_info; gboolean has_cached_info; - g_assert (class); + g_assert (klass); /* Double-checking locking pattern */ - if (class->inited || class->exception_type) - return class->exception_type == MONO_EXCEPTION_NONE; + if (klass->inited || mono_class_has_failure (klass)) + return !mono_class_has_failure (klass); - /*g_print ("Init class %s\n", mono_type_get_full_name (class));*/ + /*g_print ("Init class %s\n", mono_type_get_full_name (klass));*/ /* We do everything inside the lock to prevent races */ mono_loader_lock (); - if (class->inited || class->exception_type) { + if (klass->inited || mono_class_has_failure (klass)) { mono_loader_unlock (); /* Somebody might have gotten in before us */ - return class->exception_type == MONO_EXCEPTION_NONE; + return !mono_class_has_failure (klass); } - if (class->init_pending) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Recursive type definition detected")); + if (klass->init_pending) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Recursive type definition detected")); goto leave; } - class->init_pending = 1; + klass->init_pending = 1; - if (mono_verifier_is_enabled_for_class (class) && !mono_verifier_verify_class (class)) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, concat_two_strings_with_zero (class->image, class->name, class->image->assembly_name)); + if (mono_verifier_is_enabled_for_class (klass) && !mono_verifier_verify_class (klass)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, concat_two_strings_with_zero (klass->image, klass->name, klass->image->assembly_name)); goto leave; } - if (class->byval_arg.type == MONO_TYPE_ARRAY || class->byval_arg.type == MONO_TYPE_SZARRAY) { - MonoClass *element_class = class->element_class; + if (klass->byval_arg.type == MONO_TYPE_ARRAY || klass->byval_arg.type == MONO_TYPE_SZARRAY) { + MonoClass *element_class = klass->element_class; if (!element_class->inited) mono_class_init (element_class); - if (element_class->exception_type != MONO_EXCEPTION_NONE) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + if (mono_class_has_failure (element_class)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); goto leave; } } mono_stats.initialized_class_count++; - if (class->generic_class && !class->generic_class->is_dynamic) { - MonoClass *gklass = class->generic_class->container_class; + if (klass->generic_class && !klass->generic_class->is_dynamic) { + MonoClass *gklass = klass->generic_class->container_class; mono_stats.generic_class_count++; - class->method = gklass->method; - class->field = gklass->field; + klass->method = gklass->method; + klass->field = gklass->field; mono_class_init (gklass); // FIXME: Why is this needed ? - if (!gklass->exception_type) + if (!mono_class_has_failure (gklass)) mono_class_setup_methods (gklass); - if (gklass->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Generic Type Defintion failed to init")); + if (mono_class_has_failure (gklass)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Generic Type Defintion failed to init")); goto leave; } - if (MONO_CLASS_IS_INTERFACE (class)) - class->interface_id = mono_get_unique_iid (class); + if (MONO_CLASS_IS_INTERFACE (klass)) + klass->interface_id = mono_get_unique_iid (klass); } - if (class->parent && !class->parent->inited) - mono_class_init (class->parent); + if (klass->parent && !klass->parent->inited) + mono_class_init (klass->parent); - has_cached_info = mono_class_get_cached_class_info (class, &cached_info); + has_cached_info = mono_class_get_cached_class_info (klass, &cached_info); - if (class->generic_class || image_is_dynamic (class->image) || !class->type_token || (has_cached_info && !cached_info.has_nested_classes)) - class->nested_classes_inited = TRUE; + if (klass->generic_class || image_is_dynamic (klass->image) || !klass->type_token || (has_cached_info && !cached_info.has_nested_classes)) + klass->nested_classes_inited = TRUE; /* * Computes the size used by the fields, and their locations */ if (has_cached_info) { - class->instance_size = cached_info.instance_size; - class->sizes.class_size = cached_info.class_size; - class->packing_size = cached_info.packing_size; - class->min_align = cached_info.min_align; - class->blittable = cached_info.blittable; - class->has_references = cached_info.has_references; - class->has_static_refs = cached_info.has_static_refs; - class->no_special_static_fields = cached_info.no_special_static_fields; + klass->instance_size = cached_info.instance_size; + klass->sizes.class_size = cached_info.class_size; + klass->packing_size = cached_info.packing_size; + klass->min_align = cached_info.min_align; + klass->blittable = cached_info.blittable; + klass->has_references = cached_info.has_references; + klass->has_static_refs = cached_info.has_static_refs; + klass->no_special_static_fields = cached_info.no_special_static_fields; } else - if (!class->size_inited){ - mono_class_setup_fields (class); - if (class->exception_type || mono_loader_get_last_error ()) + if (!klass->size_inited){ + mono_class_setup_fields (klass); + if (mono_class_has_failure (klass) || mono_loader_get_last_error ()) goto leave; } /* Initialize arrays */ - if (class->rank) { - class->method.count = 3 + (class->rank > 1? 2: 1); + if (klass->rank) { + klass->method.count = 3 + (klass->rank > 1? 2: 1); - if (class->interface_count) { - int count_generic = generic_array_methods (class); - class->method.count += class->interface_count * count_generic; + if (klass->interface_count) { + int count_generic = generic_array_methods (klass); + klass->method.count += klass->interface_count * count_generic; } } - mono_class_setup_supertypes (class); + mono_class_setup_supertypes (klass); if (!default_ghc) - initialize_object_slots (class); + initialize_object_slots (klass); /* * Initialize the rest of the data without creating a generic vtable if possible. @@ -5170,74 +5201,74 @@ mono_class_init (MonoClass *class) */ if (has_cached_info) { /* AOT case */ - class->vtable_size = cached_info.vtable_size; - class->has_finalize = cached_info.has_finalize; - class->has_finalize_inited = TRUE; - class->ghcimpl = cached_info.ghcimpl; - class->has_cctor = cached_info.has_cctor; - } else if (class->rank == 1 && class->byval_arg.type == MONO_TYPE_SZARRAY) { + klass->vtable_size = cached_info.vtable_size; + klass->has_finalize = cached_info.has_finalize; + klass->has_finalize_inited = TRUE; + klass->ghcimpl = cached_info.ghcimpl; + klass->has_cctor = cached_info.has_cctor; + } else if (klass->rank == 1 && klass->byval_arg.type == MONO_TYPE_SZARRAY) { /* SZARRAY can have 2 vtable layouts, with and without the stelemref method. * The first slot if for array with. */ static int szarray_vtable_size[2] = { 0 }; - int slot = MONO_TYPE_IS_REFERENCE (&class->element_class->byval_arg) ? 0 : 1; + int slot = MONO_TYPE_IS_REFERENCE (&klass->element_class->byval_arg) ? 0 : 1; /* SZARRAY case */ if (!szarray_vtable_size [slot]) { - mono_class_setup_vtable (class); - szarray_vtable_size [slot] = class->vtable_size; + mono_class_setup_vtable (klass); + szarray_vtable_size [slot] = klass->vtable_size; } else { - class->vtable_size = szarray_vtable_size[slot]; + klass->vtable_size = szarray_vtable_size[slot]; } - } else if (class->generic_class && !MONO_CLASS_IS_INTERFACE (class)) { - MonoClass *gklass = class->generic_class->container_class; + } else if (klass->generic_class && !MONO_CLASS_IS_INTERFACE (klass)) { + MonoClass *gklass = klass->generic_class->container_class; /* Generic instance case */ - class->ghcimpl = gklass->ghcimpl; - class->has_cctor = gklass->has_cctor; + klass->ghcimpl = gklass->ghcimpl; + klass->has_cctor = gklass->has_cctor; mono_class_setup_vtable (gklass); - if (gklass->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + if (mono_class_has_failure (gklass)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); goto leave; } - class->vtable_size = gklass->vtable_size; + klass->vtable_size = gklass->vtable_size; } else { /* General case */ /* ghcimpl is not currently used - class->ghcimpl = 1; - if (class->parent) { - MonoMethod *cmethod = class->vtable [ghc_slot]; + klass->ghcimpl = 1; + if (klass->parent) { + MonoMethod *cmethod = klass->vtable [ghc_slot]; if (cmethod->is_inflated) cmethod = ((MonoMethodInflated*)cmethod)->declaring; if (cmethod == default_ghc) { - class->ghcimpl = 0; + klass->ghcimpl = 0; } } */ /* C# doesn't allow interfaces to have cctors */ - if (!MONO_CLASS_IS_INTERFACE (class) || class->image != mono_defaults.corlib) { + if (!MONO_CLASS_IS_INTERFACE (klass) || klass->image != mono_defaults.corlib) { MonoMethod *cmethod = NULL; - if (class->type_token) { - cmethod = find_method_in_metadata (class, ".cctor", 0, METHOD_ATTRIBUTE_SPECIAL_NAME); + if (klass->type_token && !image_is_dynamic(klass->image)) { + cmethod = find_method_in_metadata (klass, ".cctor", 0, METHOD_ATTRIBUTE_SPECIAL_NAME); /* The find_method function ignores the 'flags' argument */ if (cmethod && (cmethod->flags & METHOD_ATTRIBUTE_SPECIAL_NAME)) - class->has_cctor = 1; + klass->has_cctor = 1; } else { - mono_class_setup_methods (class); - if (class->exception_type) + mono_class_setup_methods (klass); + if (mono_class_has_failure (klass)) goto leave; - for (i = 0; i < class->method.count; ++i) { - MonoMethod *method = class->methods [i]; + for (i = 0; i < klass->method.count; ++i) { + MonoMethod *method = klass->methods [i]; if ((method->flags & METHOD_ATTRIBUTE_SPECIAL_NAME) && (strcmp (".cctor", method->name) == 0)) { - class->has_cctor = 1; + klass->has_cctor = 1; break; } } @@ -5245,58 +5276,58 @@ mono_class_init (MonoClass *class) } } - if (class->parent) { + if (klass->parent) { int first_iface_slot; - /* This will compute class->parent->vtable_size for some classes */ - mono_class_init (class->parent); - if (class->parent->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + /* This will compute klass->parent->vtable_size for some classes */ + mono_class_init (klass->parent); + if (mono_class_has_failure (klass->parent)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); goto leave; } if (mono_loader_get_last_error ()) goto leave; - if (!class->parent->vtable_size) { + if (!klass->parent->vtable_size) { /* FIXME: Get rid of this somehow */ - mono_class_setup_vtable (class->parent); - if (class->parent->exception_type) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + mono_class_setup_vtable (klass->parent); + if (mono_class_has_failure (klass->parent)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); goto leave; } if (mono_loader_get_last_error ()) goto leave; } - first_iface_slot = class->parent->vtable_size; - if (mono_class_need_stelemref_method (class)) + first_iface_slot = klass->parent->vtable_size; + if (mono_class_need_stelemref_method (klass)) ++first_iface_slot; - setup_interface_offsets (class, first_iface_slot, TRUE); + setup_interface_offsets (klass, first_iface_slot, TRUE); } else { - setup_interface_offsets (class, 0, TRUE); + setup_interface_offsets (klass, 0, TRUE); } if (mono_security_core_clr_enabled ()) - mono_security_core_clr_check_inheritance (class); + mono_security_core_clr_check_inheritance (klass); if (mono_loader_get_last_error ()) { - if (class->exception_type == MONO_EXCEPTION_NONE) { - set_failure_from_loader_error (class, mono_loader_get_last_error ()); + if (!mono_class_has_failure (klass)) { + set_failure_from_loader_error (klass, mono_loader_get_last_error ()); } mono_loader_clear_error (); } - if (class->generic_class && !mono_verifier_class_is_valid_generic_instantiation (class)) - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Invalid generic instantiation")); + if (klass->generic_class && !mono_verifier_class_is_valid_generic_instantiation (klass)) + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Invalid generic instantiation")); goto leave; leave: /* Because of the double-checking locking pattern */ mono_memory_barrier (); - class->inited = 1; - class->init_pending = 0; + klass->inited = 1; + klass->init_pending = 0; mono_loader_unlock (); - return class->exception_type == MONO_EXCEPTION_NONE; + return !mono_class_has_failure (klass); } /* @@ -5308,40 +5339,39 @@ mono_class_init (MonoClass *class) gboolean mono_class_has_finalizer (MonoClass *klass) { - MonoClass *class = klass; gboolean has_finalize = FALSE; if (klass->has_finalize_inited) return klass->has_finalize; /* Interfaces and valuetypes are not supposed to have finalizers */ - if (!(MONO_CLASS_IS_INTERFACE (class) || class->valuetype)) { + if (!(MONO_CLASS_IS_INTERFACE (klass) || klass->valuetype)) { MonoMethod *cmethod = NULL; - if (class->rank == 1 && class->byval_arg.type == MONO_TYPE_SZARRAY) { - } else if (class->generic_class) { - MonoClass *gklass = class->generic_class->container_class; + if (klass->rank == 1 && klass->byval_arg.type == MONO_TYPE_SZARRAY) { + } else if (klass->generic_class) { + MonoClass *gklass = klass->generic_class->container_class; has_finalize = mono_class_has_finalizer (gklass); - } else if (class->parent && class->parent->has_finalize) { + } else if (klass->parent && klass->parent->has_finalize) { has_finalize = TRUE; } else { - if (class->parent) { + if (klass->parent) { /* * Can't search in metadata for a method named Finalize, because that * ignores overrides. */ - mono_class_setup_vtable (class); - if (class->exception_type || mono_loader_get_last_error ()) + mono_class_setup_vtable (klass); + if (mono_class_has_failure (klass) || mono_loader_get_last_error ()) cmethod = NULL; else - cmethod = class->vtable [finalize_slot]; + cmethod = klass->vtable [finalize_slot]; } if (cmethod) { - g_assert (class->vtable_size > finalize_slot); + g_assert (klass->vtable_size > finalize_slot); - if (class->parent) { + if (klass->parent) { if (cmethod->is_inflated) cmethod = ((MonoMethodInflated*)cmethod)->declaring; if (cmethod != default_finalize) @@ -5379,42 +5409,45 @@ mono_is_corlib_image (MonoImage *image) * LOCKING: this assumes the loader lock is held */ void -mono_class_setup_mono_type (MonoClass *class) +mono_class_setup_mono_type (MonoClass *klass) { - const char *name = class->name; - const char *nspace = class->name_space; - gboolean is_corlib = mono_is_corlib_image (class->image); + const char *name = klass->name; + const char *nspace = klass->name_space; + gboolean is_corlib = mono_is_corlib_image (klass->image); - class->this_arg.byref = 1; - class->this_arg.data.klass = class; - class->this_arg.type = MONO_TYPE_CLASS; - class->byval_arg.data.klass = class; - class->byval_arg.type = MONO_TYPE_CLASS; + klass->this_arg.byref = 1; + klass->this_arg.data.klass = klass; + klass->this_arg.type = MONO_TYPE_CLASS; + klass->byval_arg.data.klass = klass; + klass->byval_arg.type = MONO_TYPE_CLASS; if (is_corlib && !strcmp (nspace, "System")) { if (!strcmp (name, "ValueType")) { /* * do not set the valuetype bit for System.ValueType. - * class->valuetype = 1; + * klass->valuetype = 1; */ - class->blittable = TRUE; + klass->blittable = TRUE; } else if (!strcmp (name, "Enum")) { /* * do not set the valuetype bit for System.Enum. - * class->valuetype = 1; + * klass->valuetype = 1; */ - class->valuetype = 0; - class->enumtype = 0; + klass->valuetype = 0; + klass->enumtype = 0; } else if (!strcmp (name, "Object")) { - class->this_arg.type = class->byval_arg.type = MONO_TYPE_OBJECT; + klass->byval_arg.type = MONO_TYPE_OBJECT; + klass->this_arg.type = MONO_TYPE_OBJECT; } else if (!strcmp (name, "String")) { - class->this_arg.type = class->byval_arg.type = MONO_TYPE_STRING; + klass->byval_arg.type = MONO_TYPE_STRING; + klass->this_arg.type = MONO_TYPE_STRING; } else if (!strcmp (name, "TypedReference")) { - class->this_arg.type = class->byval_arg.type = MONO_TYPE_TYPEDBYREF; + klass->byval_arg.type = MONO_TYPE_TYPEDBYREF; + klass->this_arg.type = MONO_TYPE_TYPEDBYREF; } } - if (class->valuetype) { + if (klass->valuetype) { int t = MONO_TYPE_VALUETYPE; if (is_corlib && !strcmp (nspace, "System")) { @@ -5424,7 +5457,7 @@ mono_class_setup_mono_type (MonoClass *class) t = MONO_TYPE_BOOLEAN; } else if (!strcmp(name, "Byte")) { t = MONO_TYPE_U1; - class->blittable = TRUE; + klass->blittable = TRUE; } break; case 'C': @@ -5435,52 +5468,52 @@ mono_class_setup_mono_type (MonoClass *class) case 'D': if (!strcmp (name, "Double")) { t = MONO_TYPE_R8; - class->blittable = TRUE; + klass->blittable = TRUE; } break; case 'I': if (!strcmp (name, "Int32")) { t = MONO_TYPE_I4; - class->blittable = TRUE; + klass->blittable = TRUE; } else if (!strcmp(name, "Int16")) { t = MONO_TYPE_I2; - class->blittable = TRUE; + klass->blittable = TRUE; } else if (!strcmp(name, "Int64")) { t = MONO_TYPE_I8; - class->blittable = TRUE; + klass->blittable = TRUE; } else if (!strcmp(name, "IntPtr")) { t = MONO_TYPE_I; - class->blittable = TRUE; + klass->blittable = TRUE; } break; case 'S': if (!strcmp (name, "Single")) { t = MONO_TYPE_R4; - class->blittable = TRUE; + klass->blittable = TRUE; } else if (!strcmp(name, "SByte")) { t = MONO_TYPE_I1; - class->blittable = TRUE; + klass->blittable = TRUE; } break; case 'U': if (!strcmp (name, "UInt32")) { t = MONO_TYPE_U4; - class->blittable = TRUE; + klass->blittable = TRUE; } else if (!strcmp(name, "UInt16")) { t = MONO_TYPE_U2; - class->blittable = TRUE; + klass->blittable = TRUE; } else if (!strcmp(name, "UInt64")) { t = MONO_TYPE_U8; - class->blittable = TRUE; + klass->blittable = TRUE; } else if (!strcmp(name, "UIntPtr")) { t = MONO_TYPE_U; - class->blittable = TRUE; + klass->blittable = TRUE; } break; case 'T': if (!strcmp (name, "TypedReference")) { t = MONO_TYPE_TYPEDBYREF; - class->blittable = TRUE; + klass->blittable = TRUE; } break; case 'V': @@ -5492,11 +5525,12 @@ mono_class_setup_mono_type (MonoClass *class) break; } } - class->this_arg.type = class->byval_arg.type = t; + klass->byval_arg.type = (MonoTypeEnum)t; + klass->this_arg.type = (MonoTypeEnum)t; } - if (MONO_CLASS_IS_INTERFACE (class)) - class->interface_id = mono_get_unique_iid (class); + if (MONO_CLASS_IS_INTERFACE (klass)) + klass->interface_id = mono_get_unique_iid (klass); } @@ -5508,16 +5542,16 @@ mono_class_setup_mono_type (MonoClass *class) * lacks the types that COM depends on (e.g. Variant on Silverlight). */ static void -init_com_from_comimport (MonoClass *class) +init_com_from_comimport (MonoClass *klass) { /* we don't always allow COM initialization under the CoreCLR (e.g. Moonlight does not require it) */ if (mono_security_core_clr_enabled ()) { /* but some other CoreCLR user could requires it for their platform (i.e. trusted) code */ - if (!mono_security_core_clr_determine_platform_image (class->image)) { + if (!mono_security_core_clr_determine_platform_image (klass->image)) { /* but it can not be made available for application (i.e. user code) since all COM calls * are considered native calls. In this case we fail with a TypeLoadException (just like * Silverlight 2 does */ - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); return; } } @@ -5530,30 +5564,30 @@ init_com_from_comimport (MonoClass *class) * LOCKING: this assumes the loader lock is held */ void -mono_class_setup_parent (MonoClass *class, MonoClass *parent) +mono_class_setup_parent (MonoClass *klass, MonoClass *parent) { gboolean system_namespace; - gboolean is_corlib = mono_is_corlib_image (class->image); + gboolean is_corlib = mono_is_corlib_image (klass->image); - system_namespace = !strcmp (class->name_space, "System") && is_corlib; + system_namespace = !strcmp (klass->name_space, "System") && is_corlib; /* if root of the hierarchy */ - if (system_namespace && !strcmp (class->name, "Object")) { - class->parent = NULL; - class->instance_size = sizeof (MonoObject); + if (system_namespace && !strcmp (klass->name, "Object")) { + klass->parent = NULL; + klass->instance_size = sizeof (MonoObject); return; } - if (!strcmp (class->name, "")) { - class->parent = NULL; - class->instance_size = 0; + if (!strcmp (klass->name, "")) { + klass->parent = NULL; + klass->instance_size = 0; return; } - if (!MONO_CLASS_IS_INTERFACE (class)) { + if (!MONO_CLASS_IS_INTERFACE (klass)) { /* Imported COM Objects always derive from __ComObject. */ #ifndef DISABLE_COM - if (MONO_CLASS_IS_IMPORT (class)) { - init_com_from_comimport (class); + if (MONO_CLASS_IS_IMPORT (klass)) { + init_com_from_comimport (klass); if (parent == mono_defaults.object_class) parent = mono_class_get_com_object_class (); } @@ -5561,10 +5595,10 @@ mono_class_setup_parent (MonoClass *class, MonoClass *parent) if (!parent) { /* set the parent to something useful and safe, but mark the type as broken */ parent = mono_defaults.object_class; - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); } - class->parent = parent; + klass->parent = parent; if (parent->generic_class && !parent->name) { /* @@ -5576,41 +5610,41 @@ mono_class_setup_parent (MonoClass *class, MonoClass *parent) } #ifndef DISABLE_REMOTING - class->marshalbyref = parent->marshalbyref; - class->contextbound = parent->contextbound; + klass->marshalbyref = parent->marshalbyref; + klass->contextbound = parent->contextbound; #endif - class->delegate = parent->delegate; + klass->delegate = parent->delegate; - if (MONO_CLASS_IS_IMPORT (class) || mono_class_is_com_object (parent)) - mono_class_set_is_com_object (class); + if (MONO_CLASS_IS_IMPORT (klass) || mono_class_is_com_object (parent)) + mono_class_set_is_com_object (klass); if (system_namespace) { #ifndef DISABLE_REMOTING - if (*class->name == 'M' && !strcmp (class->name, "MarshalByRefObject")) - class->marshalbyref = 1; + if (klass->name [0] == 'M' && !strcmp (klass->name, "MarshalByRefObject")) + klass->marshalbyref = 1; - if (*class->name == 'C' && !strcmp (class->name, "ContextBoundObject")) - class->contextbound = 1; + if (klass->name [0] == 'C' && !strcmp (klass->name, "ContextBoundObject")) + klass->contextbound = 1; #endif - if (*class->name == 'D' && !strcmp (class->name, "Delegate")) - class->delegate = 1; + if (klass->name [0] == 'D' && !strcmp (klass->name, "Delegate")) + klass->delegate = 1; } - if (class->parent->enumtype || (mono_is_corlib_image (class->parent->image) && (strcmp (class->parent->name, "ValueType") == 0) && - (strcmp (class->parent->name_space, "System") == 0))) - class->valuetype = 1; - if (mono_is_corlib_image (class->parent->image) && ((strcmp (class->parent->name, "Enum") == 0) && (strcmp (class->parent->name_space, "System") == 0))) { - class->valuetype = class->enumtype = 1; + if (klass->parent->enumtype || (mono_is_corlib_image (klass->parent->image) && (strcmp (klass->parent->name, "ValueType") == 0) && + (strcmp (klass->parent->name_space, "System") == 0))) + klass->valuetype = 1; + if (mono_is_corlib_image (klass->parent->image) && ((strcmp (klass->parent->name, "Enum") == 0) && (strcmp (klass->parent->name_space, "System") == 0))) { + klass->valuetype = klass->enumtype = 1; } - /*class->enumtype = class->parent->enumtype; */ + /*klass->enumtype = klass->parent->enumtype; */ } else { /* initialize com types if COM interfaces are present */ #ifndef DISABLE_COM - if (MONO_CLASS_IS_IMPORT (class)) - init_com_from_comimport (class); + if (MONO_CLASS_IS_IMPORT (klass)) + init_com_from_comimport (klass); #endif - class->parent = NULL; + klass->parent = NULL; } } @@ -5629,33 +5663,36 @@ mono_class_setup_parent (MonoClass *class, MonoClass *parent) * LOCKING: This function is atomic, in case of contention we waste memory. */ void -mono_class_setup_supertypes (MonoClass *class) +mono_class_setup_supertypes (MonoClass *klass) { int ms; MonoClass **supertypes; - mono_atomic_load_acquire (supertypes, void*, &class->supertypes); + mono_atomic_load_acquire (supertypes, MonoClass **, &klass->supertypes); if (supertypes) return; - if (class->parent && !class->parent->supertypes) - mono_class_setup_supertypes (class->parent); - if (class->parent) - class->idepth = class->parent->idepth + 1; + if (klass->parent && !klass->parent->supertypes) + mono_class_setup_supertypes (klass->parent); + if (klass->parent) + klass->idepth = klass->parent->idepth + 1; else - class->idepth = 1; + klass->idepth = 1; - ms = MAX (MONO_DEFAULT_SUPERTABLE_SIZE, class->idepth); - supertypes = mono_class_alloc0 (class, sizeof (MonoClass *) * ms); + ms = MAX (MONO_DEFAULT_SUPERTABLE_SIZE, klass->idepth); + supertypes = (MonoClass **)mono_class_alloc0 (klass, sizeof (MonoClass *) * ms); - if (class->parent) { - supertypes [class->idepth - 1] = class; - memcpy (supertypes, class->parent->supertypes, class->parent->idepth * sizeof (gpointer)); + if (klass->parent) { + CHECKED_METADATA_WRITE_PTR ( supertypes [klass->idepth - 1] , klass ); + + int supertype_idx; + for (supertype_idx = 0; supertype_idx < klass->parent->idepth; supertype_idx++) + CHECKED_METADATA_WRITE_PTR ( supertypes [supertype_idx] , klass->parent->supertypes [supertype_idx] ); } else { - supertypes [0] = class; + CHECKED_METADATA_WRITE_PTR ( supertypes [0] , klass ); } - mono_atomic_store_release (&class->supertypes, supertypes); + CHECKED_METADATA_WRITE_PTR_ATOMIC ( klass->supertypes , supertypes ); } static gboolean @@ -5674,25 +5711,25 @@ fix_gclass_incomplete_instantiation (MonoClass *gclass, void *user_data) } static void -mono_class_set_failure_and_error (MonoClass *class, MonoError *error, const char *msg) +mono_class_set_failure_and_error (MonoClass *klass, MonoError *error, const char *msg) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup (msg)); - mono_error_set_type_load_class (error, class, msg); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup (msg)); + mono_error_set_type_load_class (error, klass, msg); } static void -mono_class_set_failure_from_loader_error (MonoClass *class, MonoError *error, char *msg) +mono_class_set_failure_from_loader_error (MonoClass *klass, MonoError *error, char *msg) { MonoLoaderError *lerror = mono_loader_get_last_error (); if (lerror) { - set_failure_from_loader_error (class, lerror); + set_failure_from_loader_error (klass, lerror); mono_error_set_from_loader_error (error); if (msg) g_free (msg); } else { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, msg); - mono_error_set_type_load_class (error, class, msg); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, msg); + mono_error_set_type_load_class (error, klass, msg); } } @@ -5711,7 +5748,7 @@ static MonoClass * mono_class_create_from_typedef (MonoImage *image, guint32 type_token, MonoError *error) { MonoTableInfo *tt = &image->tables [MONO_TABLE_TYPEDEF]; - MonoClass *class, *parent = NULL; + MonoClass *klass, *parent = NULL; guint32 cols [MONO_TYPEDEF_SIZE]; guint32 cols_next [MONO_TYPEDEF_SIZE]; guint tidx = mono_metadata_token_index (type_token); @@ -5732,10 +5769,10 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token, MonoError mono_loader_lock (); - if ((class = mono_internal_hash_table_lookup (&image->class_cache, GUINT_TO_POINTER (type_token)))) { + if ((klass = (MonoClass *)mono_internal_hash_table_lookup (&image->class_cache, GUINT_TO_POINTER (type_token)))) { mono_loader_unlock (); mono_loader_assert_no_error (); - return class; + return klass; } mono_metadata_decode_row (tt, tidx - 1, cols, MONO_TYPEDEF_SIZE); @@ -5743,32 +5780,33 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token, MonoError name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]); nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]); - class = mono_image_alloc0 (image, sizeof (MonoClass)); + klass = (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClass)); - class->name = name; - class->name_space = nspace; + klass->name = name; + klass->name_space = nspace; - mono_profiler_class_event (class, MONO_PROFILE_START_LOAD); + mono_profiler_class_event (klass, MONO_PROFILE_START_LOAD); - class->image = image; - class->type_token = type_token; - class->flags = cols [MONO_TYPEDEF_FLAGS]; + klass->image = image; + klass->type_token = type_token; + klass->flags = cols [MONO_TYPEDEF_FLAGS]; - mono_internal_hash_table_insert (&image->class_cache, GUINT_TO_POINTER (type_token), class); + mono_internal_hash_table_insert (&image->class_cache, GUINT_TO_POINTER (type_token), klass); classes_size += sizeof (MonoClass); /* * Check whether we're a generic type definition. */ - class->generic_container = mono_metadata_load_generic_params (image, class->type_token, NULL); - if (class->generic_container) { - class->is_generic = 1; - class->generic_container->owner.klass = class; - context = &class->generic_container->context; + klass->generic_container = mono_metadata_load_generic_params (image, klass->type_token, NULL); + if (klass->generic_container) { + klass->is_generic = 1; + klass->generic_container->owner.klass = klass; + klass->generic_container->is_anonymous = FALSE; // Owner class is now known, container is no longer anonymous + context = &klass->generic_container->context; } - if (class->generic_container) + if (klass->generic_container) enable_gclass_recording (); if (cols [MONO_TYPEDEF_EXTENDS]) { @@ -5777,80 +5815,80 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token, MonoError if (mono_metadata_token_table (parent_token) == MONO_TABLE_TYPESPEC) { /*WARNING: this must satisfy mono_metadata_type_hash*/ - class->this_arg.byref = 1; - class->this_arg.data.klass = class; - class->this_arg.type = MONO_TYPE_CLASS; - class->byval_arg.data.klass = class; - class->byval_arg.type = MONO_TYPE_CLASS; + klass->this_arg.byref = 1; + klass->this_arg.data.klass = klass; + klass->this_arg.type = MONO_TYPE_CLASS; + klass->byval_arg.data.klass = klass; + klass->byval_arg.type = MONO_TYPE_CLASS; } parent = mono_class_get_checked (image, parent_token, error); if (parent && context) /* Always inflate */ parent = mono_class_inflate_generic_class_checked (parent, context, error); if (parent == NULL) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup (mono_error_get_message (error))); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup (mono_error_get_message (error))); goto parent_failure; } for (tmp = parent; tmp; tmp = tmp->parent) { - if (tmp == class) { - mono_class_set_failure_and_error (class, error, "Cycle found while resolving parent"); + if (tmp == klass) { + mono_class_set_failure_and_error (klass, error, "Cycle found while resolving parent"); goto parent_failure; } - if (class->generic_container && tmp->generic_class && tmp->generic_class->container_class == class) { - mono_class_set_failure_and_error (class, error, "Parent extends generic instance of this type"); + if (klass->generic_container && tmp->generic_class && tmp->generic_class->container_class == klass) { + mono_class_set_failure_and_error (klass, error, "Parent extends generic instance of this type"); goto parent_failure; } } } - mono_class_setup_parent (class, parent); + mono_class_setup_parent (klass, parent); /* uses ->valuetype, which is initialized by mono_class_setup_parent above */ - mono_class_setup_mono_type (class); + mono_class_setup_mono_type (klass); - if (class->generic_container) - disable_gclass_recording (fix_gclass_incomplete_instantiation, class); + if (klass->generic_container) + disable_gclass_recording (fix_gclass_incomplete_instantiation, klass); /* - * This might access class->byval_arg for recursion generated by generic constraints, + * This might access klass->byval_arg for recursion generated by generic constraints, * so it has to come after setup_mono_type (). */ if ((nesting_tokeen = mono_metadata_nested_in_typedef (image, type_token))) { - class->nested_in = mono_class_create_from_typedef (image, nesting_tokeen, error); + klass->nested_in = mono_class_create_from_typedef (image, nesting_tokeen, error); if (!mono_error_ok (error)) { /*FIXME implement a mono_class_set_failure_from_mono_error */ - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup (mono_error_get_message (error))); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup (mono_error_get_message (error))); mono_loader_unlock (); - mono_profiler_class_loaded (class, MONO_PROFILE_FAILED); + mono_profiler_class_loaded (klass, MONO_PROFILE_FAILED); mono_loader_assert_no_error (); return NULL; } } - if ((class->flags & TYPE_ATTRIBUTE_STRING_FORMAT_MASK) == TYPE_ATTRIBUTE_UNICODE_CLASS) - class->unicode = 1; + if ((klass->flags & TYPE_ATTRIBUTE_STRING_FORMAT_MASK) == TYPE_ATTRIBUTE_UNICODE_CLASS) + klass->unicode = 1; #ifdef HOST_WIN32 - if ((class->flags & TYPE_ATTRIBUTE_STRING_FORMAT_MASK) == TYPE_ATTRIBUTE_AUTO_CLASS) - class->unicode = 1; + if ((klass->flags & TYPE_ATTRIBUTE_STRING_FORMAT_MASK) == TYPE_ATTRIBUTE_AUTO_CLASS) + klass->unicode = 1; #endif - class->cast_class = class->element_class = class; + klass->cast_class = klass->element_class = klass; - if (!class->enumtype) { + if (!klass->enumtype) { if (!mono_metadata_interfaces_from_typedef_full ( image, type_token, &interfaces, &icount, FALSE, context, error)){ - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup (mono_error_get_message (error))); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup (mono_error_get_message (error))); mono_loader_unlock (); - mono_profiler_class_loaded (class, MONO_PROFILE_FAILED); + mono_profiler_class_loaded (klass, MONO_PROFILE_FAILED); return NULL; } - class->interfaces = interfaces; - class->interface_count = icount; - class->interfaces_inited = 1; + klass->interfaces = interfaces; + klass->interface_count = icount; + klass->interfaces_inited = 1; } /*g_print ("Load class %s\n", name);*/ @@ -5858,8 +5896,8 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token, MonoError /* * Compute the field and method lists */ - class->field.first = cols [MONO_TYPEDEF_FIELD_LIST] - 1; - class->method.first = cols [MONO_TYPEDEF_METHOD_LIST] - 1; + klass->field.first = cols [MONO_TYPEDEF_FIELD_LIST] - 1; + klass->method.first = cols [MONO_TYPEDEF_METHOD_LIST] - 1; if (tt->rows > tidx){ mono_metadata_decode_row (tt, tidx, cols_next, MONO_TYPEDEF_SIZE); @@ -5872,33 +5910,33 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token, MonoError if (cols [MONO_TYPEDEF_FIELD_LIST] && cols [MONO_TYPEDEF_FIELD_LIST] <= image->tables [MONO_TABLE_FIELD].rows) - class->field.count = field_last - class->field.first; + klass->field.count = field_last - klass->field.first; else - class->field.count = 0; + klass->field.count = 0; if (cols [MONO_TYPEDEF_METHOD_LIST] <= image->tables [MONO_TABLE_METHOD].rows) - class->method.count = method_last - class->method.first; + klass->method.count = method_last - klass->method.first; else - class->method.count = 0; + klass->method.count = 0; /* reserve space to store vector pointer in arrays */ if (mono_is_corlib_image (image) && !strcmp (nspace, "System") && !strcmp (name, "Array")) { - class->instance_size += 2 * sizeof (gpointer); - g_assert (class->field.count == 0); + klass->instance_size += 2 * sizeof (gpointer); + g_assert (klass->field.count == 0); } - if (class->enumtype) { - MonoType *enum_basetype = mono_class_find_enum_basetype (class, error); + if (klass->enumtype) { + MonoType *enum_basetype = mono_class_find_enum_basetype (klass, error); if (!enum_basetype) { /*set it to a default value as the whole runtime can't handle this to be null*/ - class->cast_class = class->element_class = mono_defaults.int32_class; - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup (mono_error_get_message (error))); + klass->cast_class = klass->element_class = mono_defaults.int32_class; + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup (mono_error_get_message (error))); mono_loader_unlock (); - mono_profiler_class_loaded (class, MONO_PROFILE_FAILED); + mono_profiler_class_loaded (klass, MONO_PROFILE_FAILED); mono_loader_assert_no_error (); return NULL; } - class->cast_class = class->element_class = mono_class_from_mono_type (enum_basetype); + klass->cast_class = klass->element_class = mono_class_from_mono_type (enum_basetype); } /* @@ -5906,35 +5944,35 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token, MonoError * We must do this after the class has been constructed to make certain recursive scenarios * work. */ - if (class->generic_container && !mono_metadata_load_generic_param_constraints_checked (image, type_token, class->generic_container, error)) { - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Could not load generic parameter constrains due to %s", mono_error_get_message (error))); + if (klass->generic_container && !mono_metadata_load_generic_param_constraints_checked (image, type_token, klass->generic_container, error)) { + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup_printf ("Could not load generic parameter constrains due to %s", mono_error_get_message (error))); mono_loader_unlock (); - mono_profiler_class_loaded (class, MONO_PROFILE_FAILED); + mono_profiler_class_loaded (klass, MONO_PROFILE_FAILED); mono_loader_assert_no_error (); return NULL; } - if (class->image->assembly_name && !strcmp (class->image->assembly_name, "Mono.Simd") && !strcmp (nspace, "Mono.Simd")) { + if (klass->image->assembly_name && !strcmp (klass->image->assembly_name, "Mono.Simd") && !strcmp (nspace, "Mono.Simd")) { if (!strncmp (name, "Vector", 6)) - class->simd_type = !strcmp (name + 6, "2d") || !strcmp (name + 6, "2ul") || !strcmp (name + 6, "2l") || !strcmp (name + 6, "4f") || !strcmp (name + 6, "4ui") || !strcmp (name + 6, "4i") || !strcmp (name + 6, "8s") || !strcmp (name + 6, "8us") || !strcmp (name + 6, "16b") || !strcmp (name + 6, "16sb"); + klass->simd_type = !strcmp (name + 6, "2d") || !strcmp (name + 6, "2ul") || !strcmp (name + 6, "2l") || !strcmp (name + 6, "4f") || !strcmp (name + 6, "4ui") || !strcmp (name + 6, "4i") || !strcmp (name + 6, "8s") || !strcmp (name + 6, "8us") || !strcmp (name + 6, "16b") || !strcmp (name + 6, "16sb"); } mono_loader_unlock (); - mono_profiler_class_loaded (class, MONO_PROFILE_OK); + mono_profiler_class_loaded (klass, MONO_PROFILE_OK); mono_loader_assert_no_error (); - return class; + return klass; parent_failure: - mono_class_setup_mono_type (class); + mono_class_setup_mono_type (klass); mono_loader_unlock (); - mono_profiler_class_loaded (class, MONO_PROFILE_FAILED); + mono_profiler_class_loaded (klass, MONO_PROFILE_FAILED); mono_loader_assert_no_error (); return NULL; } -/** is klass Nullable? */ +/** Is klass a Nullable ginst? */ gboolean mono_class_is_nullable (MonoClass *klass) { @@ -5994,7 +6032,7 @@ mono_generic_class_get_class (MonoGenericClass *gclass) return gclass->cached_class; } - klass = mono_image_set_alloc0 (gclass->owner, sizeof (MonoClass)); + klass = (MonoClass *)mono_image_set_alloc0 (gclass->owner, sizeof (MonoClass)); gklass = gclass->container_class; @@ -6019,7 +6057,8 @@ mono_generic_class_get_class (MonoGenericClass *gclass) klass->is_inflated = 1; klass->generic_class = gclass; - klass->this_arg.type = klass->byval_arg.type = MONO_TYPE_GENERICINST; + klass->byval_arg.type = MONO_TYPE_GENERICINST; + klass->this_arg.type = klass->byval_arg.type; klass->this_arg.data.generic_class = klass->byval_arg.data.generic_class = gclass; klass->this_arg.byref = TRUE; klass->enumtype = gklass->enumtype; @@ -6074,42 +6113,83 @@ mono_generic_class_get_class (MonoGenericClass *gclass) return klass; } +static MonoImage * +get_image_for_container (MonoGenericContainer *container) +{ + MonoImage *result; + if (container->is_anonymous) { + result = container->owner.image; + } else { + MonoClass *klass; + if (container->is_method) { + MonoMethod *method = container->owner.method; + g_assert_checked (method); + klass = method->klass; + } else { + klass = container->owner.klass; + } + g_assert_checked (klass); + result = klass->image; + } + g_assert (result); + return result; +} + +MonoImage * +get_image_for_generic_param (MonoGenericParam *param) +{ + MonoGenericContainer *container = mono_generic_param_owner (param); + g_assert_checked (container); + return get_image_for_container (container); +} + +// Make a string in the designated image consisting of a single integer. +#define INT_STRING_SIZE 16 +char * +make_generic_name_string (MonoImage *image, int num) +{ + char *name = (char *)mono_image_alloc0 (image, INT_STRING_SIZE); + g_snprintf (name, INT_STRING_SIZE, "%d", num); + return name; +} + +// This is called by mono_class_from_generic_parameter_internal when a new class must be created. +// pinfo is derived from param by the caller for us. static MonoClass* -make_generic_param_class (MonoGenericParam *param, MonoImage *image, gboolean is_mvar, MonoGenericParamInfo *pinfo) +make_generic_param_class (MonoGenericParam *param, MonoGenericParamInfo *pinfo) { MonoClass *klass, **ptr; int count, pos, i; MonoGenericContainer *container = mono_generic_param_owner (param); + g_assert_checked (container); - if (!image) - /* FIXME: */ - image = mono_defaults.corlib; + MonoImage *image = get_image_for_container (container); + gboolean is_mvar = container->is_method; + gboolean is_anonymous = container->is_anonymous; - klass = mono_image_alloc0 (image, sizeof (MonoClass)); + klass = (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClass)); classes_size += sizeof (MonoClass); if (pinfo) { - klass->name = pinfo->name; + CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name , pinfo->name ); } else { int n = mono_generic_param_num (param); - klass->name = mono_image_alloc0 (image, 16); - sprintf ((char*)klass->name, "%d", n); + CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->name , make_generic_name_string (image, n) ); } - if (container) { - if (is_mvar) { - MonoMethod *omethod = container->owner.method; - klass->name_space = (omethod && omethod->klass) ? omethod->klass->name_space : ""; - } else { - MonoClass *oklass = container->owner.klass; - klass->name_space = oklass ? oklass->name_space : ""; - } + if (is_anonymous) { + CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name_space , "" ); + } else if (is_mvar) { + MonoMethod *omethod = container->owner.method; + CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name_space , (omethod && omethod->klass) ? omethod->klass->name_space : "" ); } else { - klass->name_space = ""; + MonoClass *oklass = container->owner.klass; + CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name_space , oklass ? oklass->name_space : "" ); } mono_profiler_class_event (klass, MONO_PROFILE_START_LOAD); + // Count non-NULL items in pinfo->constraints count = 0; if (pinfo) for (ptr = pinfo->constraints; ptr && *ptr; ptr++, count++) @@ -6117,30 +6197,33 @@ make_generic_param_class (MonoGenericParam *param, MonoImage *image, gboolean is pos = 0; if ((count > 0) && !MONO_CLASS_IS_INTERFACE (pinfo->constraints [0])) { - klass->parent = pinfo->constraints [0]; + CHECKED_METADATA_WRITE_PTR ( klass->parent , pinfo->constraints [0] ); pos++; - } else if (pinfo && pinfo->flags & GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT) - klass->parent = mono_class_from_name (mono_defaults.corlib, "System", "ValueType"); - else - klass->parent = mono_defaults.object_class; - + } else if (pinfo && pinfo->flags & GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT) { + CHECKED_METADATA_WRITE_PTR ( klass->parent , mono_class_load_from_name (mono_defaults.corlib, "System", "ValueType") ); + } else { + CHECKED_METADATA_WRITE_PTR ( klass->parent , mono_defaults.object_class ); + } if (count - pos > 0) { klass->interface_count = count - pos; - klass->interfaces = mono_image_alloc0 (image, sizeof (MonoClass *) * (count - pos)); + CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->interfaces , (MonoClass **)mono_image_alloc0 (image, sizeof (MonoClass *) * (count - pos)) ); klass->interfaces_inited = TRUE; for (i = pos; i < count; i++) - klass->interfaces [i - pos] = pinfo->constraints [i]; + CHECKED_METADATA_WRITE_PTR ( klass->interfaces [i - pos] , pinfo->constraints [i] ); } - klass->image = image; + CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->image , image ); klass->inited = TRUE; - klass->cast_class = klass->element_class = klass; + CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->cast_class , klass ); + CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->element_class , klass ); klass->flags = TYPE_ATTRIBUTE_PUBLIC; - klass->this_arg.type = klass->byval_arg.type = is_mvar ? MONO_TYPE_MVAR : MONO_TYPE_VAR; - klass->this_arg.data.generic_param = klass->byval_arg.data.generic_param = param; + klass->byval_arg.type = is_mvar ? MONO_TYPE_MVAR : MONO_TYPE_VAR; + klass->this_arg.type = klass->byval_arg.type; + CHECKED_METADATA_WRITE_PTR ( klass->this_arg.data.generic_param , param ); + CHECKED_METADATA_WRITE_PTR ( klass->byval_arg.data.generic_param , param ); klass->this_arg.byref = TRUE; /* We don't use type_token for VAR since only classes can use it (not arrays, pointer, VARs, etc) */ @@ -6161,7 +6244,7 @@ make_generic_param_class (MonoGenericParam *param, MonoImage *image, gboolean is if (count - pos > 0) { mono_class_setup_vtable (klass->parent); - if (klass->parent->exception_type) + if (mono_class_has_failure (klass->parent)) mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup ("Failed to setup parent interfaces")); else setup_interface_offsets (klass, klass->parent->vtable_size, TRUE); @@ -6173,24 +6256,31 @@ make_generic_param_class (MonoGenericParam *param, MonoImage *image, gboolean is #define FAST_CACHE_SIZE 16 /* + * get_anon_gparam_class and set_anon_gparam_class are helpers for mono_class_from_generic_parameter_internal. + * The latter will sometimes create MonoClasses for anonymous generic params. To prevent this being wasteful, + * we cache the MonoClasses. + * FIXME: It would be better to instead cache anonymous MonoGenericParams, and allow anonymous params to point directly to classes using the pklass field. * LOCKING: Takes the image lock depending on @take_lock. */ static MonoClass * -get_anon_gparam_class (MonoGenericParam *param, gboolean is_mvar, gboolean take_lock) +get_anon_gparam_class (MonoGenericParam *param, gboolean take_lock) { int n = mono_generic_param_num (param); - MonoImage *image = param->image; + MonoImage *image = get_image_for_generic_param (param); + gboolean is_mvar = mono_generic_param_owner (param)->is_method; MonoClass *klass = NULL; GHashTable *ht; g_assert (image); + // For params with a small num and no constraints, we use a "fast" cache which does simple num lookup in an array. + // For high numbers or constraints we have to use pointer hashes. if (param->gshared_constraint) { ht = is_mvar ? image->mvar_cache_constrained : image->var_cache_constrained; if (ht) { if (take_lock) mono_image_lock (image); - klass = g_hash_table_lookup (ht, param); + klass = (MonoClass *)g_hash_table_lookup (ht, param); if (take_lock) mono_image_unlock (image); } @@ -6207,7 +6297,7 @@ get_anon_gparam_class (MonoGenericParam *param, gboolean is_mvar, gboolean take_ if (ht) { if (take_lock) mono_image_lock (image); - klass = g_hash_table_lookup (ht, GINT_TO_POINTER (n)); + klass = (MonoClass *)g_hash_table_lookup (ht, GINT_TO_POINTER (n)); if (take_lock) mono_image_unlock (image); } @@ -6219,10 +6309,11 @@ get_anon_gparam_class (MonoGenericParam *param, gboolean is_mvar, gboolean take_ * LOCKING: Image lock (param->image) must be held */ static void -set_anon_gparam_class (MonoGenericParam *param, gboolean is_mvar, MonoClass *klass) +set_anon_gparam_class (MonoGenericParam *param, MonoClass *klass) { int n = mono_generic_param_num (param); - MonoImage *image = param->image; + MonoImage *image = get_image_for_generic_param (param); + gboolean is_mvar = mono_generic_param_owner (param)->is_method; g_assert (image); @@ -6241,11 +6332,11 @@ set_anon_gparam_class (MonoGenericParam *param, gboolean is_mvar, MonoClass *kla if (is_mvar) { /* Requires locking to avoid droping an already published class */ if (!image->mvar_cache_fast) - image->mvar_cache_fast = mono_image_alloc0 (image, sizeof (MonoClass*) * FAST_CACHE_SIZE); + image->mvar_cache_fast = (MonoClass **)mono_image_alloc0 (image, sizeof (MonoClass*) * FAST_CACHE_SIZE); image->mvar_cache_fast [n] = klass; } else { if (!image->var_cache_fast) - image->var_cache_fast = mono_image_alloc0 (image, sizeof (MonoClass*) * FAST_CACHE_SIZE); + image->var_cache_fast = (MonoClass **)mono_image_alloc0 (image, sizeof (MonoClass*) * FAST_CACHE_SIZE); image->var_cache_fast [n] = klass; } } else { @@ -6269,66 +6360,71 @@ set_anon_gparam_class (MonoGenericParam *param, gboolean is_mvar, MonoClass *kla * LOCKING: Acquires the image lock (@image). */ MonoClass * -mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gboolean is_mvar) +mono_class_from_generic_parameter_internal (MonoGenericParam *param) { - MonoGenericContainer *container = mono_generic_param_owner (param); - MonoGenericParamInfo *pinfo = NULL; + MonoImage *image = get_image_for_generic_param (param); + MonoGenericParamInfo *pinfo = mono_generic_param_info (param); MonoClass *klass, *klass2; - if (container) { - pinfo = mono_generic_param_info (param); + // If a klass already exists for this object and is cached, return it. + if (pinfo) // Non-anonymous klass = pinfo->pklass; - } else { - image = NULL; - klass = get_anon_gparam_class (param, is_mvar, TRUE); - } + else // Anonymous + klass = get_anon_gparam_class (param, TRUE); + if (klass) return klass; - if (!image && container) { - if (is_mvar) { - MonoMethod *method = container->owner.method; - image = (method && method->klass) ? method->klass->image : NULL; - } else { - MonoClass *klass = container->owner.klass; - // FIXME: 'klass' should not be null - // But, monodis creates GenericContainers without associating a owner to it - image = klass ? klass->image : NULL; - } - } - - klass = make_generic_param_class (param, image, is_mvar, pinfo); + // Create a new klass + klass = make_generic_param_class (param, pinfo); + // Now we need to cache the klass we created. + // But since we wait to grab the lock until after creating the klass, we need to check to make sure + // another thread did not get in and cache a klass ahead of us. In that case, return their klass + // and allow our newly-created klass object to just leak. mono_memory_barrier (); - if (!image) //FIXME is this only needed by monodis? Can't we fix monodis instead of having this hack? - image = mono_defaults.corlib; - mono_image_lock (image); - if (container) + + // Here "klass2" refers to the klass potentially created by the other thread. + if (pinfo) // Repeat check from above klass2 = pinfo->pklass; else - klass2 = get_anon_gparam_class (param, is_mvar, FALSE); + klass2 = get_anon_gparam_class (param, FALSE); if (klass2) { klass = klass2; } else { - if (container) + // Cache here + if (pinfo) pinfo->pklass = klass; else - set_anon_gparam_class (param, is_mvar, klass); + set_anon_gparam_class (param, klass); } mono_image_unlock (image); /* FIXME: Should this go inside 'make_generic_param_klass'? */ if (klass2) - mono_profiler_class_loaded (klass2, MONO_PROFILE_FAILED); + mono_profiler_class_loaded (klass2, MONO_PROFILE_FAILED); // Alert profiler about botched class create else mono_profiler_class_loaded (klass, MONO_PROFILE_OK); return klass; } +/** + * mono_class_from_generic_parameter: + * @param: Parameter to find/construct a class for. + * @arg2: Is ignored. + * @arg3: Is ignored. + */ +MonoClass * +mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *arg2 G_GNUC_UNUSED, gboolean arg3 G_GNUC_UNUSED) +{ + return mono_class_from_generic_parameter_internal (param); +} + + MonoClass * mono_ptr_class_get (MonoType *type) { @@ -6342,14 +6438,14 @@ mono_ptr_class_get (MonoType *type) mono_image_lock (image); if (image->ptr_cache) { - if ((result = g_hash_table_lookup (image->ptr_cache, el_class))) { + if ((result = (MonoClass *)g_hash_table_lookup (image->ptr_cache, el_class))) { mono_image_unlock (image); return result; } } mono_image_unlock (image); - result = mono_image_alloc0 (image, sizeof (MonoClass)); + result = (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClass)); classes_size += sizeof (MonoClass); @@ -6369,7 +6465,8 @@ mono_ptr_class_get (MonoType *type) result->cast_class = result->element_class = el_class; result->blittable = TRUE; - result->this_arg.type = result->byval_arg.type = MONO_TYPE_PTR; + result->byval_arg.type = MONO_TYPE_PTR; + result->this_arg.type = result->byval_arg.type; result->this_arg.data.type = result->byval_arg.data.type = &result->element_class->byval_arg; result->this_arg.byref = TRUE; @@ -6378,7 +6475,7 @@ mono_ptr_class_get (MonoType *type) mono_image_lock (image); if (image->ptr_cache) { MonoClass *result2; - if ((result2 = g_hash_table_lookup (image->ptr_cache, el_class))) { + if ((result2 = (MonoClass *)g_hash_table_lookup (image->ptr_cache, el_class))) { mono_image_unlock (image); mono_profiler_class_loaded (result, MONO_PROFILE_FAILED); return result2; @@ -6407,7 +6504,7 @@ mono_fnptr_class_get (MonoMethodSignature *sig) if (!ptr_hash) ptr_hash = g_hash_table_new (mono_aligned_addr_hash, NULL); - if ((result = g_hash_table_lookup (ptr_hash, sig))) { + if ((result = (MonoClass *)g_hash_table_lookup (ptr_hash, sig))) { mono_loader_unlock (); return result; } @@ -6427,7 +6524,8 @@ mono_fnptr_class_get (MonoMethodSignature *sig) result->cast_class = result->element_class = result; result->blittable = TRUE; - result->this_arg.type = result->byval_arg.type = MONO_TYPE_FNPTR; + result->byval_arg.type = MONO_TYPE_FNPTR; + result->this_arg.type = result->byval_arg.type; result->this_arg.data.method = result->byval_arg.data.method = sig; result->this_arg.byref = TRUE; result->blittable = TRUE; @@ -6443,6 +6541,12 @@ mono_fnptr_class_get (MonoMethodSignature *sig) return result; } +/** + * mono_class_from_mono_type: + * @type: describes the type to return + * + * This returns a MonoClass for the specified MonoType, the value is never NULL. + */ MonoClass * mono_class_from_mono_type (MonoType *type) { @@ -6496,15 +6600,16 @@ mono_class_from_mono_type (MonoType *type) return type->data.klass; case MONO_TYPE_GENERICINST: return mono_generic_class_get_class (type->data.generic_class); - case MONO_TYPE_VAR: - return mono_class_from_generic_parameter (type->data.generic_param, NULL, FALSE); case MONO_TYPE_MVAR: - return mono_class_from_generic_parameter (type->data.generic_param, NULL, TRUE); + case MONO_TYPE_VAR: + return mono_class_from_generic_parameter_internal (type->data.generic_param); default: g_warning ("mono_class_from_mono_type: implement me 0x%02x\n", type->type); g_assert_not_reached (); } - + + // Yes, this returns NULL, even if it is documented as not doing so, but there + // is no way for the code to make it this far, due to the assert above. return NULL; } @@ -6552,8 +6657,7 @@ mono_class_create_from_typespec (MonoImage *image, guint32 type_spec, MonoGeneri MonoClass *ret; gboolean inflated = FALSE; MonoType *t = mono_type_retrieve_from_typespec (image, type_spec, context, &inflated, error); - if (!mono_error_ok (error)) - return NULL; + return_val_if_nok (error, NULL); ret = mono_class_from_mono_type (t); if (inflated) mono_metadata_free_type (t); @@ -6566,14 +6670,14 @@ mono_class_create_from_typespec (MonoImage *image, guint32 type_spec, MonoGeneri * @rank: the dimension of the array class * @bounded: whenever the array has non-zero bounds * - * Returns: a class object describing the array with element type @element_type and + * Returns: A class object describing the array with element type @element_type and * dimension @rank. */ MonoClass * mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded) { MonoImage *image; - MonoClass *class; + MonoClass *klass; MonoClass *parent = NULL; GSList *list, *rootlist = NULL; int nsize; @@ -6594,13 +6698,13 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded) * from mono_class_from_mono_type (), mono_array_new (), * Array:CreateInstance (), etc, so use a separate cache + a separate lock. */ - mono_mutex_lock (&image->szarray_cache_lock); + mono_os_mutex_lock (&image->szarray_cache_lock); if (!image->szarray_cache) image->szarray_cache = g_hash_table_new (mono_aligned_addr_hash, NULL); - class = g_hash_table_lookup (image->szarray_cache, eclass); - mono_mutex_unlock (&image->szarray_cache_lock); - if (class) - return class; + klass = (MonoClass *)g_hash_table_lookup (image->szarray_cache, eclass); + mono_os_mutex_unlock (&image->szarray_cache_lock); + if (klass) + return klass; mono_loader_lock (); } else { @@ -6609,12 +6713,12 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded) if (!image->array_cache) image->array_cache = g_hash_table_new (mono_aligned_addr_hash, NULL); - if ((rootlist = list = g_hash_table_lookup (image->array_cache, eclass))) { + if ((rootlist = list = (GSList *)g_hash_table_lookup (image->array_cache, eclass))) { for (; list; list = list->next) { - class = list->data; - if ((class->rank == rank) && (class->byval_arg.type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) { + klass = (MonoClass *)list->data; + if ((klass->rank == rank) && (klass->byval_arg.type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) { mono_loader_unlock (); - return class; + return klass; } } } @@ -6622,7 +6726,7 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded) /* for the building corlib use System.Array from it */ if (image->assembly && assembly_is_dynamic (image->assembly) && image->assembly_name && strcmp (image->assembly_name, "mscorlib") == 0) { - parent = mono_class_from_name (image, "System", "Array"); + parent = mono_class_load_from_name (image, "System", "Array"); corlib_type = TRUE; } else { parent = mono_defaults.array_class; @@ -6630,12 +6734,12 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded) mono_class_init (parent); } - class = mono_image_alloc0 (image, sizeof (MonoClass)); + klass = (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClass)); - class->image = image; - class->name_space = eclass->name_space; + klass->image = image; + klass->name_space = eclass->name_space; nsize = strlen (eclass->name); - name = g_malloc (nsize + 2 + rank + 1); + name = (char *)g_malloc (nsize + 2 + rank + 1); memcpy (name, eclass->name, nsize); name [nsize] = '['; if (rank > 1) @@ -6644,117 +6748,117 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded) name [nsize + rank] = '*'; name [nsize + rank + bounded] = ']'; name [nsize + rank + bounded + 1] = 0; - class->name = mono_image_strdup (image, name); + klass->name = mono_image_strdup (image, name); g_free (name); - mono_profiler_class_event (class, MONO_PROFILE_START_LOAD); + mono_profiler_class_event (klass, MONO_PROFILE_START_LOAD); classes_size += sizeof (MonoClass); - class->type_token = 0; + klass->type_token = 0; /* all arrays are marked serializable and sealed, bug #42779 */ - class->flags = TYPE_ATTRIBUTE_CLASS | TYPE_ATTRIBUTE_SERIALIZABLE | TYPE_ATTRIBUTE_SEALED | TYPE_ATTRIBUTE_PUBLIC; - class->parent = parent; - class->instance_size = mono_class_instance_size (class->parent); + klass->flags = TYPE_ATTRIBUTE_CLASS | TYPE_ATTRIBUTE_SERIALIZABLE | TYPE_ATTRIBUTE_SEALED | TYPE_ATTRIBUTE_PUBLIC; + klass->parent = parent; + klass->instance_size = mono_class_instance_size (klass->parent); if (eclass->byval_arg.type == MONO_TYPE_TYPEDBYREF || eclass->byval_arg.type == MONO_TYPE_VOID) { /*Arrays of those two types are invalid.*/ - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); } else if (eclass->enumtype && !mono_class_enum_basetype (eclass)) { if (!eclass->ref_info_handle || eclass->wastypebuilder) { g_warning ("Only incomplete TypeBuilder objects are allowed to be an enum without base_type"); g_assert (eclass->ref_info_handle && !eclass->wastypebuilder); } /* element_size -1 is ok as this is not an instantitable type*/ - class->sizes.element_size = -1; + klass->sizes.element_size = -1; } else - class->sizes.element_size = mono_class_array_element_size (eclass); + klass->sizes.element_size = mono_class_array_element_size (eclass); - mono_class_setup_supertypes (class); + mono_class_setup_supertypes (klass); if (eclass->generic_class) mono_class_init (eclass); if (!eclass->size_inited) mono_class_setup_fields (eclass); - if (eclass->exception_type) /*FIXME we fail the array type, but we have to let other fields be set.*/ - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + if (mono_class_has_failure (eclass)) /*FIXME we fail the array type, but we have to let other fields be set.*/ + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL); - class->has_references = MONO_TYPE_IS_REFERENCE (&eclass->byval_arg) || eclass->has_references? TRUE: FALSE; + klass->has_references = MONO_TYPE_IS_REFERENCE (&eclass->byval_arg) || eclass->has_references? TRUE: FALSE; - class->rank = rank; + klass->rank = rank; if (eclass->enumtype) - class->cast_class = eclass->element_class; + klass->cast_class = eclass->element_class; else - class->cast_class = eclass; + klass->cast_class = eclass; - switch (class->cast_class->byval_arg.type) { + switch (klass->cast_class->byval_arg.type) { case MONO_TYPE_I1: - class->cast_class = mono_defaults.byte_class; + klass->cast_class = mono_defaults.byte_class; break; case MONO_TYPE_U2: - class->cast_class = mono_defaults.int16_class; + klass->cast_class = mono_defaults.int16_class; break; case MONO_TYPE_U4: #if SIZEOF_VOID_P == 4 case MONO_TYPE_I: case MONO_TYPE_U: #endif - class->cast_class = mono_defaults.int32_class; + klass->cast_class = mono_defaults.int32_class; break; case MONO_TYPE_U8: #if SIZEOF_VOID_P == 8 case MONO_TYPE_I: case MONO_TYPE_U: #endif - class->cast_class = mono_defaults.int64_class; + klass->cast_class = mono_defaults.int64_class; break; default: break; } - class->element_class = eclass; + klass->element_class = eclass; if ((rank > 1) || bounded) { - MonoArrayType *at = mono_image_alloc0 (image, sizeof (MonoArrayType)); - class->byval_arg.type = MONO_TYPE_ARRAY; - class->byval_arg.data.array = at; + MonoArrayType *at = (MonoArrayType *)mono_image_alloc0 (image, sizeof (MonoArrayType)); + klass->byval_arg.type = MONO_TYPE_ARRAY; + klass->byval_arg.data.array = at; at->eklass = eclass; at->rank = rank; /* FIXME: complete.... */ } else { - class->byval_arg.type = MONO_TYPE_SZARRAY; - class->byval_arg.data.klass = eclass; + klass->byval_arg.type = MONO_TYPE_SZARRAY; + klass->byval_arg.data.klass = eclass; } - class->this_arg = class->byval_arg; - class->this_arg.byref = 1; + klass->this_arg = klass->byval_arg; + klass->this_arg.byref = 1; if (corlib_type) { - class->inited = 1; + klass->inited = 1; } - class->generic_container = eclass->generic_container; + klass->generic_container = eclass->generic_container; if (rank == 1 && !bounded) { MonoClass *prev_class; - mono_mutex_lock (&image->szarray_cache_lock); - prev_class = g_hash_table_lookup (image->szarray_cache, eclass); + mono_os_mutex_lock (&image->szarray_cache_lock); + prev_class = (MonoClass *)g_hash_table_lookup (image->szarray_cache, eclass); if (prev_class) /* Someone got in before us */ - class = prev_class; + klass = prev_class; else - g_hash_table_insert (image->szarray_cache, eclass, class); - mono_mutex_unlock (&image->szarray_cache_lock); + g_hash_table_insert (image->szarray_cache, eclass, klass); + mono_os_mutex_unlock (&image->szarray_cache_lock); } else { - list = g_slist_append (rootlist, class); + list = g_slist_append (rootlist, klass); g_hash_table_insert (image->array_cache, eclass, list); } mono_loader_unlock (); - mono_profiler_class_loaded (class, MONO_PROFILE_OK); + mono_profiler_class_loaded (klass, MONO_PROFILE_OK); - return class; + return klass; } /** @@ -6762,7 +6866,7 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded) * @element_class: element class * @rank: the dimension of the array class * - * Returns: a class object describing the array with element type @element_type and + * Returns: A class object describing the array with element type @element_type and * dimension @rank. */ MonoClass * @@ -6774,8 +6878,10 @@ mono_array_class_get (MonoClass *eclass, guint32 rank) /** * mono_class_instance_size: * @klass: a class - * - * Returns: the size of an object instance + * + * Use to get the size of a class in bytes. + * + * Returns: The size of an object instance */ gint32 mono_class_instance_size (MonoClass *klass) @@ -6789,7 +6895,9 @@ mono_class_instance_size (MonoClass *klass) /** * mono_class_min_align: * @klass: a class - * + * + * Use to get the computed minimum alignment requirements for the specified class. + * * Returns: minimm alignment requirements */ gint32 @@ -6832,7 +6940,7 @@ mono_class_value_size (MonoClass *klass, guint32 *align) * mono_class_data_size: * @klass: a class * - * Returns: the size of the static class data + * Returns: The size of the static class data */ gint32 mono_class_data_size (MonoClass *klass) @@ -6857,34 +6965,34 @@ mono_class_data_size (MonoClass *klass) * Takes a field index instead of a field token. */ static MonoClassField * -mono_class_get_field_idx (MonoClass *class, int idx) +mono_class_get_field_idx (MonoClass *klass, int idx) { - mono_class_setup_fields_locking (class); - if (class->exception_type) + mono_class_setup_fields_locking (klass); + if (mono_class_has_failure (klass)) return NULL; - while (class) { - if (class->image->uncompressed_metadata) { + while (klass) { + if (klass->image->uncompressed_metadata) { /* - * class->field.first points to the FieldPtr table, while idx points into the + * klass->field.first points to the FieldPtr table, while idx points into the * Field table, so we have to do a search. */ /*FIXME this is broken for types with multiple fields with the same name.*/ - const char *name = mono_metadata_string_heap (class->image, mono_metadata_decode_row_col (&class->image->tables [MONO_TABLE_FIELD], idx, MONO_FIELD_NAME)); + const char *name = mono_metadata_string_heap (klass->image, mono_metadata_decode_row_col (&klass->image->tables [MONO_TABLE_FIELD], idx, MONO_FIELD_NAME)); int i; - for (i = 0; i < class->field.count; ++i) - if (mono_field_get_name (&class->fields [i]) == name) - return &class->fields [i]; + for (i = 0; i < klass->field.count; ++i) + if (mono_field_get_name (&klass->fields [i]) == name) + return &klass->fields [i]; g_assert_not_reached (); } else { - if (class->field.count) { - if ((idx >= class->field.first) && (idx < class->field.first + class->field.count)){ - return &class->fields [idx - class->field.first]; + if (klass->field.count) { + if ((idx >= klass->field.first) && (idx < klass->field.first + klass->field.count)){ + return &klass->fields [idx - klass->field.first]; } } } - class = class->parent; + klass = klass->parent; } return NULL; } @@ -6899,13 +7007,13 @@ mono_class_get_field_idx (MonoClass *class, int idx) * class. */ MonoClassField * -mono_class_get_field (MonoClass *class, guint32 field_token) +mono_class_get_field (MonoClass *klass, guint32 field_token) { int idx = mono_metadata_token_index (field_token); g_assert (mono_metadata_token_code (field_token) == MONO_TOKEN_FIELD_DEF); - return mono_class_get_field_idx (class, idx - 1); + return mono_class_get_field_idx (klass, idx - 1); } /** @@ -6915,7 +7023,7 @@ mono_class_get_field (MonoClass *class, guint32 field_token) * * Search the class @klass and it's parents for a field with the name @name. * - * Returns: the MonoClassField pointer of the named field or NULL + * Returns: The MonoClassField pointer of the named field or NULL */ MonoClassField * mono_class_get_field_from_name (MonoClass *klass, const char *name) @@ -6934,7 +7042,7 @@ mono_class_get_field_from_name (MonoClass *klass, const char *name) * If @klass is an inflated generic type, the type comparison is done with the equivalent field * of its generic type definition. * - * Returns: the MonoClassField pointer of the named field or NULL + * Returns: The MonoClassField pointer of the named field or NULL */ MonoClassField * mono_class_get_field_from_name_full (MonoClass *klass, const char *name, MonoType *type) @@ -6942,7 +7050,7 @@ mono_class_get_field_from_name_full (MonoClass *klass, const char *name, MonoTyp int i; mono_class_setup_fields_locking (klass); - if (klass->exception_type) + if (mono_class_has_failure (klass)) return NULL; while (klass) { @@ -6971,7 +7079,7 @@ mono_class_get_field_from_name_full (MonoClass *klass, const char *name, MonoTyp * Get the token of a field. Note that the tokesn is only valid for the image * the field was loaded from. Don't use this function for fields in dynamic types. * - * Returns: the token representing the field in the image it was loaded from. + * Returns: The token representing the field in the image it was loaded from. */ guint32 mono_class_get_field_token (MonoClassField *field) @@ -7030,7 +7138,7 @@ mono_class_get_field_default_value (MonoClassField *field, MonoTypeEnum *def_typ mono_class_alloc_ext (klass); - def_values = mono_class_alloc0 (klass, sizeof (MonoFieldDefaultValue) * klass->field.count); + def_values = (MonoFieldDefaultValue *)mono_class_alloc0 (klass, sizeof (MonoFieldDefaultValue) * klass->field.count); mono_image_lock (klass->image); mono_memory_barrier (); @@ -7049,8 +7157,8 @@ mono_class_get_field_default_value (MonoClassField *field, MonoTypeEnum *def_typ g_assert (!(field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA)); mono_metadata_decode_row (&field->parent->image->tables [MONO_TABLE_CONSTANT], cindex - 1, constant_cols, MONO_CONSTANT_SIZE); - klass->ext->field_def_values [field_index].def_type = constant_cols [MONO_CONSTANT_TYPE]; - klass->ext->field_def_values [field_index].data = (gpointer)mono_metadata_blob_heap (field->parent->image, constant_cols [MONO_CONSTANT_VALUE]); + klass->ext->field_def_values [field_index].def_type = (MonoTypeEnum)constant_cols [MONO_CONSTANT_TYPE]; + klass->ext->field_def_values [field_index].data = (const char *)mono_metadata_blob_heap (field->parent->image, constant_cols [MONO_CONSTANT_VALUE]); } *def_type = klass->ext->field_def_values [field_index].def_type; @@ -7099,8 +7207,8 @@ mono_class_get_property_default_value (MonoProperty *property, MonoTypeEnum *def return NULL; mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_CONSTANT], cindex - 1, constant_cols, MONO_CONSTANT_SIZE); - *def_type = constant_cols [MONO_CONSTANT_TYPE]; - return (gpointer)mono_metadata_blob_heap (klass->image, constant_cols [MONO_CONSTANT_VALUE]); + *def_type = (MonoTypeEnum)constant_cols [MONO_CONSTANT_TYPE]; + return (const char *)mono_metadata_blob_heap (klass->image, constant_cols [MONO_CONSTANT_VALUE]); } guint32 @@ -7123,6 +7231,15 @@ mono_class_get_event_token (MonoEvent *event) return 0; } +/** + * mono_class_get_property_from_name: + * @klass: a class + * @name: name of the property to lookup in the specified class + * + * Use this method to lookup a property in a class + * Returns: the MonoProperty with the given name, or NULL if the property + * does not exist on the @klass. + */ MonoProperty* mono_class_get_property_from_name (MonoClass *klass, const char *name) { @@ -7138,6 +7255,12 @@ mono_class_get_property_from_name (MonoClass *klass, const char *name) return NULL; } +/** + * mono_class_get_property_token: + * @prop: MonoProperty to query + * + * Returns: The ECMA token for the specified property. + */ guint32 mono_class_get_property_token (MonoProperty *prop) { @@ -7281,35 +7404,35 @@ mono_assembly_name_from_token (MonoImage *image, guint32 type_token) * @context: the generic context used to evaluate generic instantiations in * @deprecated: Functions that expose MonoGenericContext are going away in mono 4.0 * - * Returns: the MonoClass that represents @type_token in @image + * Returns: The MonoClass that represents @type_token in @image */ MonoClass * mono_class_get_full (MonoImage *image, guint32 type_token, MonoGenericContext *context) { MonoError error; - MonoClass *class; - class = mono_class_get_checked (image, type_token, &error); + MonoClass *klass; + klass = mono_class_get_checked (image, type_token, &error); - if (class && context && mono_metadata_token_table (type_token) == MONO_TABLE_TYPESPEC) - class = mono_class_inflate_generic_class_checked (class, context, &error); + if (klass && context && mono_metadata_token_table (type_token) == MONO_TABLE_TYPESPEC) + klass = mono_class_inflate_generic_class_checked (klass, context, &error); g_assert (mono_error_ok (&error)); /* FIXME deprecate this function and forbit the runtime from using it. */ - return class; + return klass; } MonoClass * mono_class_get_and_inflate_typespec_checked (MonoImage *image, guint32 type_token, MonoGenericContext *context, MonoError *error) { - MonoClass *class; + MonoClass *klass; mono_error_init (error); - class = mono_class_get_checked (image, type_token, error); + klass = mono_class_get_checked (image, type_token, error); - if (class && context && mono_metadata_token_table (type_token) == MONO_TABLE_TYPESPEC) - class = mono_class_inflate_generic_class_checked (class, context, error); + if (klass && context && mono_metadata_token_table (type_token) == MONO_TABLE_TYPESPEC) + klass = mono_class_inflate_generic_class_checked (klass, context, error); - return class; + return klass; } /** * mono_class_get_checked: @@ -7317,12 +7440,12 @@ mono_class_get_and_inflate_typespec_checked (MonoImage *image, guint32 type_toke * @type_token: the token for the class * @error: error object to return any error * - * Returns: the MonoClass that represents @type_token in @image + * Returns: The MonoClass that represents @type_token in @image, or NULL on error. */ MonoClass * mono_class_get_checked (MonoImage *image, guint32 type_token, MonoError *error) { - MonoClass *class = NULL; + MonoClass *klass = NULL; mono_error_init (error); @@ -7333,19 +7456,19 @@ mono_class_get_checked (MonoImage *image, guint32 type_token, MonoError *error) mono_error_set_bad_image (error, image,"Bad token table for dynamic image: %x", table); return NULL; } - class = mono_lookup_dynamic_token (image, type_token, NULL); /*FIXME proper error handling*/ + klass = (MonoClass *)mono_lookup_dynamic_token (image, type_token, NULL); /*FIXME proper error handling*/ goto done; } switch (type_token & 0xff000000){ case MONO_TOKEN_TYPE_DEF: - class = mono_class_create_from_typedef (image, type_token, error); + klass = mono_class_create_from_typedef (image, type_token, error); break; case MONO_TOKEN_TYPE_REF: - class = mono_class_from_typeref_checked (image, type_token, error); + klass = mono_class_from_typeref_checked (image, type_token, error); break; case MONO_TOKEN_TYPE_SPEC: - class = mono_class_create_from_typespec (image, type_token, NULL, error); + klass = mono_class_create_from_typespec (image, type_token, NULL, error); break; default: mono_error_set_bad_image (error, image, "Unknown type token %x", type_token & 0xff000000); @@ -7353,13 +7476,13 @@ mono_class_get_checked (MonoImage *image, guint32 type_token, MonoError *error) done: /* Generic case, should be avoided for when a better error is possible. */ - if (!class && mono_error_ok (error)) { + if (!klass && mono_error_ok (error)) { char *name = mono_class_name_from_token (image, type_token); char *assembly = mono_assembly_name_from_token (image, type_token); mono_error_set_type_load_name (error, name, assembly, "Could not resolve type with token %08x", type_token); } - return class; + return klass; } @@ -7372,7 +7495,7 @@ done: * * This functions exists to fullfill the fact that sometimes it's desirable to have access to the * - * Returns: the MonoType that represents @type_token in @image + * Returns: The MonoType that represents @type_token in @image */ MonoType * mono_type_get_checked (MonoImage *image, guint32 type_token, MonoGenericContext *context, MonoError *error) @@ -7384,18 +7507,18 @@ mono_type_get_checked (MonoImage *image, guint32 type_token, MonoGenericContext //FIXME: this will not fix the very issue for which mono_type_get_full exists -but how to do it then? if (image_is_dynamic (image)) - return mono_class_get_type (mono_lookup_dynamic_token (image, type_token, context)); + return mono_class_get_type ((MonoClass *)mono_lookup_dynamic_token (image, type_token, context)); if ((type_token & 0xff000000) != MONO_TOKEN_TYPE_SPEC) { - MonoClass *class = mono_class_get_checked (image, type_token, error); + MonoClass *klass = mono_class_get_checked (image, type_token, error); - if (!class) { + if (!klass) { mono_loader_assert_no_error (); return NULL; } - g_assert (class); - return mono_class_get_type (class); + g_assert (klass); + return mono_class_get_type (klass); } type = mono_type_retrieve_from_typespec (image, type_token, context, &inflated, error); @@ -7422,7 +7545,13 @@ mono_type_get_checked (MonoImage *image, guint32 type_token, MonoGenericContext return type; } - +/** + * mono_class_get: + * @image: image where the class token will be looked up. + * @type_token: a type token from the image + * + * Returns the MonoClass with the given @type_token on the @image + */ MonoClass * mono_class_get (MonoImage *image, guint32 type_token) { @@ -7479,7 +7608,7 @@ mono_image_init_name_cache (MonoImage *image) nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]); nspace_index = cols [MONO_TYPEDEF_NAMESPACE]; - nspace_table = g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index)); + nspace_table = (GHashTable *)g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index)); if (!nspace_table) { nspace_table = g_hash_table_new (g_str_hash, g_str_equal); g_hash_table_insert (the_name_cache, (char*)nspace, nspace_table); @@ -7497,11 +7626,17 @@ mono_image_init_name_cache (MonoImage *image) for (i = 0; i < t->rows; ++i) { mono_metadata_decode_row (t, i, cols, MONO_EXP_TYPE_SIZE); + + guint32 impl = cols [MONO_EXP_TYPE_IMPLEMENTATION]; + if ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_EXP_TYPE) + /* Nested type */ + continue; + name = mono_metadata_string_heap (image, cols [MONO_EXP_TYPE_NAME]); nspace = mono_metadata_string_heap (image, cols [MONO_EXP_TYPE_NAMESPACE]); nspace_index = cols [MONO_EXP_TYPE_NAMESPACE]; - nspace_table = g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index)); + nspace_table = (GHashTable *)g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index)); if (!nspace_table) { nspace_table = g_hash_table_new (g_str_hash, g_str_equal); g_hash_table_insert (the_name_cache, (char*)nspace, nspace_table); @@ -7537,7 +7672,7 @@ mono_image_add_to_name_cache (MonoImage *image, const char *nspace, mono_image_lock (image); name_cache = image->name_cache; - if (!(nspace_table = g_hash_table_lookup (name_cache, nspace))) { + if (!(nspace_table = (GHashTable *)g_hash_table_lookup (name_cache, nspace))) { nspace_table = g_hash_table_new (g_str_hash, g_str_equal); g_hash_table_insert (name_cache, (char *)nspace, (char *)nspace_table); } @@ -7570,7 +7705,7 @@ find_nocase (gpointer key, gpointer value, gpointer user_data) * @image: The MonoImage where the type is looked up in * @name_space: the type namespace * @name: the type short name. - * @deprecated: use the _checked variant + * @deprecated: use the mono_class_from_name_case_checked variant instead. * * Obtains a MonoClass with a given namespace and a given name which * is located in the given MonoImage. The namespace and name @@ -7581,12 +7716,28 @@ mono_class_from_name_case (MonoImage *image, const char* name_space, const char { MonoError error; MonoClass *res = mono_class_from_name_case_checked (image, name_space, name, &error); - g_assert (!mono_error_ok (&error)); + mono_error_cleanup (&error); + return res; } +/** + * mono_class_from_name_case: + * @image: The MonoImage where the type is looked up in + * @name_space: the type namespace + * @name: the type short name. + * @error: if + * + * Obtains a MonoClass with a given namespace and a given name which + * is located in the given MonoImage. The namespace and name + * lookups are case insensitive. + * + * Returns: The MonoClass if the given namespace and name were found, or NULL if it + * was not found. The @error object will contain information about the problem + * in that case. + */ MonoClass * -mono_class_from_name_case_checked (MonoImage *image, const char* name_space, const char *name, MonoError *error) +mono_class_from_name_case_checked (MonoImage *image, const char *name_space, const char *name, MonoError *error) { MonoTableInfo *t = &image->tables [MONO_TABLE_TYPEDEF]; guint32 cols [MONO_TYPEDEF_SIZE]; @@ -7647,7 +7798,7 @@ mono_class_from_name_case_checked (MonoImage *image, const char* name_space, con } static MonoClass* -return_nested_in (MonoClass *class, char *nested) +return_nested_in (MonoClass *klass, char *nested) { MonoClass *found; char *s = strchr (nested, '/'); @@ -7658,7 +7809,7 @@ return_nested_in (MonoClass *class, char *nested) s++; } - while ((found = mono_class_get_nested_types (class, &iter))) { + while ((found = mono_class_get_nested_types (klass, &iter))) { if (strcmp (found->name, nested) == 0) { if (s) return return_nested_in (found, s); @@ -7669,13 +7820,15 @@ return_nested_in (MonoClass *class, char *nested) } static MonoClass* -search_modules (MonoImage *image, const char *name_space, const char *name) +search_modules (MonoImage *image, const char *name_space, const char *name, MonoError *error) { MonoTableInfo *file_table = &image->tables [MONO_TABLE_FILE]; MonoImage *file_image; - MonoClass *class; + MonoClass *klass; int i; + mono_error_init (error); + /* * The EXPORTEDTYPES table only contains public types, so have to search the * modules as well. @@ -7690,9 +7843,9 @@ search_modules (MonoImage *image, const char *name_space, const char *name) file_image = mono_image_load_file_for_image (image, i + 1); if (file_image) { - class = mono_class_from_name (file_image, name_space, name); - if (class) - return class; + klass = mono_class_from_name_checked (file_image, name_space, name, error); + if (klass || !is_ok (error)) + return klass; } } @@ -7700,13 +7853,13 @@ search_modules (MonoImage *image, const char *name_space, const char *name) } static MonoClass * -mono_class_from_name_checked_aux (MonoImage *image, const char* name_space, const char *name, MonoError *error, GHashTable* visited_images) +mono_class_from_name_checked_aux (MonoImage *image, const char* name_space, const char *name, GHashTable* visited_images, MonoError *error) { GHashTable *nspace_table; MonoImage *loaded_image; guint32 token = 0; int i; - MonoClass *class; + MonoClass *klass; char *nested; char buf [1024]; @@ -7731,21 +7884,24 @@ mono_class_from_name_checked_aux (MonoImage *image, const char* name_space, cons /* FIXME: get_class_from_name () can't handle types in the EXPORTEDTYPE table */ if (get_class_from_name && image->tables [MONO_TABLE_EXPORTEDTYPE].rows == 0) { - gboolean res = get_class_from_name (image, name_space, name, &class); + gboolean res = get_class_from_name (image, name_space, name, &klass); if (res) { - if (!class) - class = search_modules (image, name_space, name); + if (!klass) { + klass = search_modules (image, name_space, name, error); + if (!is_ok (error)) + return NULL; + } if (nested) - return class ? return_nested_in (class, nested) : NULL; + return klass ? return_nested_in (klass, nested) : NULL; else - return class; + return klass; } } mono_image_init_name_cache (image); mono_image_lock (image); - nspace_table = g_hash_table_lookup (image->name_cache, name_space); + nspace_table = (GHashTable *)g_hash_table_lookup (image->name_cache, name_space); if (nspace_table) token = GPOINTER_TO_UINT (g_hash_table_lookup (nspace_table, name)); @@ -7757,16 +7913,16 @@ mono_class_from_name_checked_aux (MonoImage *image, const char* name_space, cons for (i = 0; i < image->module_count; ++i) { MonoImage *module = image->modules [i]; - class = mono_class_from_name (module, name_space, name); - if (class) - return class; + klass = mono_class_from_name_checked (module, name_space, name, error); + if (klass || !is_ok (error)) + return klass; } } if (!token) { - class = search_modules (image, name_space, name); - if (class) - return class; + klass = search_modules (image, name_space, name, error); + if (klass || !is_ok (error)) + return klass; } if (!token) @@ -7786,10 +7942,10 @@ mono_class_from_name_checked_aux (MonoImage *image, const char* name_space, cons loaded_image = mono_assembly_load_module (image->assembly, impl >> MONO_IMPLEMENTATION_BITS); if (!loaded_image) return NULL; - class = mono_class_from_name_checked_aux (loaded_image, name_space, name, error, visited_images); + klass = mono_class_from_name_checked_aux (loaded_image, name_space, name, visited_images, error); if (nested) - return return_nested_in (class, nested); - return class; + return klass ? return_nested_in (klass, nested) : NULL; + return klass; } else if ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_ASSEMBLYREF) { guint32 assembly_idx; @@ -7799,21 +7955,35 @@ mono_class_from_name_checked_aux (MonoImage *image, const char* name_space, cons g_assert (image->references [assembly_idx - 1]); if (image->references [assembly_idx - 1] == (gpointer)-1) return NULL; - else - return mono_class_from_name_checked_aux (image->references [assembly_idx - 1]->image, name_space, name, error, visited_images); + klass = mono_class_from_name_checked_aux (image->references [assembly_idx - 1]->image, name_space, name, visited_images, error); + if (nested) + return klass ? return_nested_in (klass, nested) : NULL; + return klass; } else { - g_error ("not yet implemented"); + g_assert_not_reached (); } } token = MONO_TOKEN_TYPE_DEF | token; - class = mono_class_get_checked (image, token, error); + klass = mono_class_get_checked (image, token, error); if (nested) - return return_nested_in (class, nested); - return class; + return return_nested_in (klass, nested); + return klass; } +/** + * mono_class_from_name_checked: + * @image: The MonoImage where the type is looked up in + * @name_space: the type namespace + * @name: the type short name. + * + * Obtains a MonoClass with a given namespace and a given name which + * is located in the given MonoImage. + * + * Works like mono_class_from_name, but error handling is tricky. It can return NULL and have no error + * set if the class was not found or it will return NULL and set the error if there was a loading error. + */ MonoClass * mono_class_from_name_checked (MonoImage *image, const char* name_space, const char *name, MonoError *error) { @@ -7822,7 +7992,7 @@ mono_class_from_name_checked (MonoImage *image, const char* name_space, const ch visited_images = g_hash_table_new (g_direct_hash, g_direct_equal); - klass = mono_class_from_name_checked_aux (image, name_space, name, error, visited_images); + klass = mono_class_from_name_checked_aux (image, name_space, name, visited_images, error); g_hash_table_destroy (visited_images); @@ -7849,13 +8019,61 @@ mono_class_from_name (MonoImage *image, const char* name_space, const char *name MonoClass *klass; klass = mono_class_from_name_checked (image, name_space, name, &error); - if (!mono_error_ok (&error)) { - mono_loader_set_error_from_mono_error (&error); - mono_error_cleanup (&error); /* FIXME Don't swallow the error */ - } + mono_error_cleanup (&error); /* FIXME Don't swallow the error */ + + return klass; +} + +/** + * mono_class_load_from_name: + * @image: The MonoImage where the type is looked up in + * @name_space: the type namespace + * @name: the type short name. + * + * This function works exactly like mono_class_from_name but it will abort if the class is not found. + * This function should be used by the runtime for critical types to which there's no way to recover but crash + * If they are missing. Thing of System.Object or System.String. + */ +MonoClass * +mono_class_load_from_name (MonoImage *image, const char* name_space, const char *name) +{ + MonoError error; + MonoClass *klass; + + klass = mono_class_from_name_checked (image, name_space, name, &error); + if (!klass) + g_error ("Runtime critical type %s.%s not found", name_space, name); + if (!mono_error_ok (&error)) + g_error ("Could not load runtime critical type %s.%s due to %s", name_space, name, mono_error_get_message (&error)); + return klass; +} + +/** + * mono_class_try_load_from_name: + * @image: The MonoImage where the type is looked up in + * @name_space: the type namespace + * @name: the type short name. + * + * This function tries to load a type, returning the class was found or NULL otherwise. + * This function should be used by the runtime when probing for optional types, those that could have being linked out. + * + * Big design consideration. This function aborts if there was an error loading the type. This prevents us from missing + * a type that we would otherwise assume to be available but was not due some error. + * + */ +MonoClass* +mono_class_try_load_from_name (MonoImage *image, const char* name_space, const char *name) +{ + MonoError error; + MonoClass *klass; + + klass = mono_class_from_name_checked (image, name_space, name, &error); + if (!mono_error_ok (&error)) + g_error ("Could not load runtime critical type %s.%s due to %s", name_space, name, mono_error_get_message (&error)); return klass; } + /** * mono_class_is_subclass_of: * @klass: class to probe if it is a subclass of another one @@ -7865,11 +8083,11 @@ mono_class_from_name (MonoImage *image, const char* name_space, const char *name * This method determines whether @klass is a subclass of @klassc. * * If the @check_interfaces flag is set, then if @klassc is an interface - * this method return true if the @klass implements the interface or + * this method return TRUE if the @klass implements the interface or * if @klass is an interface, if one of its base classes is @klass. * * If @check_interfaces is false then, then if @klass is not an interface - * then it returns true if the @klass is a subclass of @klassc. + * then it returns TRUE if the @klass is a subclass of @klassc. * * if @klass is an interface and @klassc is System.Object, then this function * return true. @@ -7956,8 +8174,9 @@ mono_gparam_is_reference_conversible (MonoClass *target, MonoClass *candidate, g * @klass: the class to be assigned to * @oklass: the source class * - * Both klass and oklass must be instances of the same generic interface. - * Return true if @klass can be assigned to a @klass variable + * Both @klass and @oklass must be instances of the same generic interface. + * + * Returns: TRUE if @klass can be assigned to a @klass variable */ gboolean mono_class_is_variant_compatible (MonoClass *klass, MonoClass *oklass, gboolean check_for_reference_conv) @@ -8108,7 +8327,7 @@ mono_gparam_is_assignable_from (MonoClass *target, MonoClass *candidate) * @klass: the class to be assigned to * @oklass: the source class * - * Return: true if an instance of object oklass can be assigned to an + * Returns: TRUE if an instance of object oklass can be assigned to an * instance of object @klass */ gboolean @@ -8121,7 +8340,7 @@ mono_class_is_assignable_from (MonoClass *klass, MonoClass *oklass) if (!oklass->inited) mono_class_init (oklass); - if (klass->exception_type || oklass->exception_type) + if (mono_class_has_failure (klass) || mono_class_has_failure (oklass)) return FALSE; if (mono_type_is_generic_argument (&klass->byval_arg)) { @@ -8276,7 +8495,7 @@ mono_class_implement_interface_slow (MonoClass *target, MonoClass *candidate) /*A TypeBuilder can have more interfaces on tb->interfaces than on candidate->interfaces*/ if (image_is_dynamic (candidate->image) && !candidate->wastypebuilder) { - MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (candidate); + MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (candidate); int j; if (tb && tb->interfaces) { for (j = mono_array_length (tb->interfaces) - 1; j >= 0; --j) { @@ -8382,7 +8601,7 @@ mono_class_is_assignable_from_slow (MonoClass *target, MonoClass *candidate) * mono_class_get_cctor: * @klass: A MonoClass pointer * - * Returns: the static constructor of @klass if it exists, NULL otherwise. + * Returns: The static constructor of @klass if it exists, NULL otherwise. */ MonoMethod* mono_class_get_cctor (MonoClass *klass) @@ -8418,7 +8637,7 @@ mono_class_get_cctor (MonoClass *klass) * mono_class_get_finalizer: * @klass: The MonoClass pointer * - * Returns: the finalizer method of @klass if it exists, NULL otherwise. + * Returns: The finalizer method of @klass if it exists, NULL otherwise. */ MonoMethod* mono_class_get_finalizer (MonoClass *klass) @@ -8466,7 +8685,7 @@ mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller) * mono_class_array_element_size: * @klass: * - * Returns: the number of bytes an element of type @klass + * Returns: The number of bytes an element of type @klass * uses when stored into an array. */ gint32 @@ -8530,7 +8749,7 @@ handle_enum: * mono_array_element_size: * @ac: pointer to a #MonoArrayClass * - * Returns: the size of single array element. + * Returns: The size of single array element. */ gint32 mono_array_element_size (MonoClass *ac) @@ -8585,7 +8804,7 @@ mono_ldtoken_checked (MonoImage *image, guint32 token, MonoClass **handle_class, return type; } case MONO_TOKEN_FIELD_DEF: { - MonoClass *class; + MonoClass *klass; guint32 type = mono_metadata_typedef_from_field (image, mono_metadata_token_index (token)); if (!type) { mono_error_set_bad_image (error, image, "Bad ldtoken %x", token); @@ -8593,12 +8812,12 @@ mono_ldtoken_checked (MonoImage *image, guint32 token, MonoClass **handle_class, } if (handle_class) *handle_class = mono_defaults.fieldhandle_class; - class = mono_class_get_and_inflate_typespec_checked (image, MONO_TOKEN_TYPE_DEF | type, context, error); - if (!class) + klass = mono_class_get_and_inflate_typespec_checked (image, MONO_TOKEN_TYPE_DEF | type, context, error); + if (!klass) return NULL; - mono_class_init (class); - return mono_class_get_field (class, token); + mono_class_init (klass); + return mono_class_get_field (klass, token); } case MONO_TOKEN_METHOD_DEF: case MONO_TOKEN_METHOD_SPEC: { @@ -8687,6 +8906,13 @@ mono_install_get_class_from_name (MonoGetClassFromName func) get_class_from_name = func; } +/** + * mono_class_get_image: + * + * Use this method to get the `MonoImage*` where this class came from. + * + * Returns: The image where this class is defined. + */ MonoImage* mono_class_get_image (MonoClass *klass) { @@ -8697,7 +8923,9 @@ mono_class_get_image (MonoClass *klass) * mono_class_get_element_class: * @klass: the MonoClass to act on * - * Returns: the element class of an array or an enumeration. + * Use this function to get the element class of an array. + * + * Returns: The element class of an array. */ MonoClass* mono_class_get_element_class (MonoClass *klass) @@ -8709,7 +8937,10 @@ mono_class_get_element_class (MonoClass *klass) * mono_class_is_valuetype: * @klass: the MonoClass to act on * - * Returns: true if the MonoClass represents a ValueType. + * Use this method to determine if the provided `MonoClass*` represents a value type, + * or a reference type. + * + * Returns: TRUE if the MonoClass represents a ValueType, FALSE if it represents a reference type. */ gboolean mono_class_is_valuetype (MonoClass *klass) @@ -8721,7 +8952,9 @@ mono_class_is_valuetype (MonoClass *klass) * mono_class_is_enum: * @klass: the MonoClass to act on * - * Returns: true if the MonoClass represents an enumeration. + * Use this function to determine if the provided `MonoClass*` represents an enumeration. + * + * Returns: TRUE if the MonoClass represents an enumeration. */ gboolean mono_class_is_enum (MonoClass *klass) @@ -8733,7 +8966,9 @@ mono_class_is_enum (MonoClass *klass) * mono_class_enum_basetype: * @klass: the MonoClass to act on * - * Returns: the underlying type representation for an enumeration. + * Use this function to get the underlying type for an enumeration value. + * + * Returns: The underlying type representation for an enumeration. */ MonoType* mono_class_enum_basetype (MonoClass *klass) @@ -8749,7 +8984,7 @@ mono_class_enum_basetype (MonoClass *klass) * mono_class_get_parent * @klass: the MonoClass to act on * - * Returns: the parent class for this class. + * Returns: The parent class for this class. */ MonoClass* mono_class_get_parent (MonoClass *klass) @@ -8758,10 +8993,14 @@ mono_class_get_parent (MonoClass *klass) } /** - * mono_class_get_nesting_type; + * mono_class_get_nesting_type: * @klass: the MonoClass to act on * - * Returns: the container type where this type is nested or NULL if this type is not a nested type. + * Use this function to obtain the class that the provided `MonoClass*` is nested on. + * + * If the return is NULL, this indicates that this class is not nested. + * + * Returns: The container type where this type is nested or NULL if this type is not a nested type. */ MonoClass* mono_class_get_nesting_type (MonoClass *klass) @@ -8773,7 +9012,7 @@ mono_class_get_nesting_type (MonoClass *klass) * mono_class_get_rank: * @klass: the MonoClass to act on * - * Returns: the rank for the array (the number of dimensions). + * Returns: The rank for the array (the number of dimensions). */ int mono_class_get_rank (MonoClass *klass) @@ -8789,7 +9028,7 @@ mono_class_get_rank (MonoClass *klass) * see the TYPE_ATTRIBUTE_* definitions on tabledefs.h for the * different values. * - * Returns: the flags from the TypeDef table. + * Returns: The flags from the TypeDef table. */ guint32 mono_class_get_flags (MonoClass *klass) @@ -8801,7 +9040,7 @@ mono_class_get_flags (MonoClass *klass) * mono_class_get_name * @klass: the MonoClass to act on * - * Returns: the name of the class. + * Returns: The name of the class. */ const char* mono_class_get_name (MonoClass *klass) @@ -8813,7 +9052,7 @@ mono_class_get_name (MonoClass *klass) * mono_class_get_namespace: * @klass: the MonoClass to act on * - * Returns: the namespace of the class. + * Returns: The namespace of the class. */ const char* mono_class_get_namespace (MonoClass *klass) @@ -8827,7 +9066,7 @@ mono_class_get_namespace (MonoClass *klass) * * This method returns the internal Type representation for the class. * - * Returns: the MonoType from the class. + * Returns: The MonoType from the class. */ MonoType* mono_class_get_type (MonoClass *klass) @@ -8836,12 +9075,12 @@ mono_class_get_type (MonoClass *klass) } /** - * mono_class_get_type_token + * mono_class_get_type_token: * @klass: the MonoClass to act on * * This method returns type token for the class. * - * Returns: the type token for the class. + * Returns: The type token for the class. */ guint32 mono_class_get_type_token (MonoClass *klass) @@ -8865,7 +9104,7 @@ mono_class_get_byref_type (MonoClass *klass) * mono_class_num_fields: * @klass: the MonoClass to act on * - * Returns: the number of static and instance fields in the class. + * Returns: The number of static and instance fields in the class. */ int mono_class_num_fields (MonoClass *klass) @@ -8877,7 +9116,7 @@ mono_class_num_fields (MonoClass *klass) * mono_class_num_methods: * @klass: the MonoClass to act on * - * Returns: the number of methods in the class. + * Returns: The number of methods in the class. */ int mono_class_num_methods (MonoClass *klass) @@ -8889,7 +9128,7 @@ mono_class_num_methods (MonoClass *klass) * mono_class_num_properties * @klass: the MonoClass to act on * - * Returns: the number of properties in the class. + * Returns: The number of properties in the class. */ int mono_class_num_properties (MonoClass *klass) @@ -8903,7 +9142,7 @@ mono_class_num_properties (MonoClass *klass) * mono_class_num_events: * @klass: the MonoClass to act on * - * Returns: the number of events in the class. + * Returns: The number of events in the class. */ int mono_class_num_events (MonoClass *klass) @@ -8933,20 +9172,22 @@ mono_class_get_fields (MonoClass* klass, gpointer *iter) return NULL; if (!*iter) { mono_class_setup_fields_locking (klass); - if (klass->exception_type) + if (mono_class_has_failure (klass)) return NULL; /* start from the first */ if (klass->field.count) { - return *iter = &klass->fields [0]; + *iter = &klass->fields [0]; + return &klass->fields [0]; } else { /* no fields */ return NULL; } } - field = *iter; + field = (MonoClassField *)*iter; field++; if (field < &klass->fields [klass->field.count]) { - return *iter = field; + *iter = field; + return field; } return NULL; } @@ -8987,7 +9228,7 @@ mono_class_get_methods (MonoClass* klass, gpointer *iter) return NULL; } } - method = *iter; + method = (MonoMethod **)*iter; method++; if (method < &klass->methods [klass->method.count]) { *iter = method; @@ -9021,7 +9262,7 @@ mono_class_get_virtual_methods (MonoClass* klass, gpointer *iter) /* start from the first */ method = &klass->methods [0]; } else { - method = *iter; + method = (MonoMethod **)*iter; method++; } while (method < &klass->methods [klass->method.count]) { @@ -9049,7 +9290,7 @@ mono_class_get_virtual_methods (MonoClass* klass, gpointer *iter) for (i = start_index; i < klass->method.count; ++i) { guint32 flags; - /* class->method.first points into the methodptr table */ + /* klass->method.first points into the methodptr table */ flags = mono_metadata_decode_table_row_col (klass->image, MONO_TABLE_METHOD, klass->method.first + i, MONO_METHOD_FLAGS); if (flags & METHOD_ATTRIBUTE_VIRTUAL) @@ -9092,16 +9333,18 @@ mono_class_get_properties (MonoClass* klass, gpointer *iter) mono_class_setup_properties (klass); /* start from the first */ if (klass->ext->property.count) { - return *iter = &klass->ext->properties [0]; + *iter = &klass->ext->properties [0]; + return (MonoProperty *)*iter; } else { /* no fields */ return NULL; } } - property = *iter; + property = (MonoProperty *)*iter; property++; if (property < &klass->ext->properties [klass->ext->property.count]) { - return *iter = property; + *iter = property; + return (MonoProperty *)*iter; } return NULL; } @@ -9128,16 +9371,18 @@ mono_class_get_events (MonoClass* klass, gpointer *iter) mono_class_setup_events (klass); /* start from the first */ if (klass->ext->event.count) { - return *iter = &klass->ext->events [0]; + *iter = &klass->ext->events [0]; + return (MonoEvent *)*iter; } else { /* no fields */ return NULL; } } - event = *iter; + event = (MonoEvent *)*iter; event++; if (event < &klass->ext->events [klass->ext->event.count]) { - return *iter = event; + *iter = event; + return (MonoEvent *)*iter; } return NULL; } @@ -9180,7 +9425,7 @@ mono_class_get_interfaces (MonoClass* klass, gpointer *iter) return NULL; } } - iface = *iter; + iface = (MonoClass **)*iter; iface++; if (iface < &klass->interfaces [klass->interface_count]) { *iter = iface; @@ -9268,17 +9513,17 @@ mono_class_get_nested_types (MonoClass* klass, gpointer *iter) /* start from the first */ if (klass->ext && klass->ext->nested_classes) { *iter = klass->ext->nested_classes; - return klass->ext->nested_classes->data; + return (MonoClass *)klass->ext->nested_classes->data; } else { /* no nested types */ return NULL; } } - item = *iter; + item = (GList *)*iter; item = item->next; if (item) { *iter = item; - return item->data; + return (MonoClass *)item->data; } return NULL; } @@ -9288,7 +9533,7 @@ mono_class_get_nested_types (MonoClass* klass, gpointer *iter) * mono_class_is_delegate * @klass: the MonoClass to act on * - * Returns: true if the MonoClass represents a System.Delegate. + * Returns: TRUE if the MonoClass represents a System.Delegate. */ mono_bool mono_class_is_delegate (MonoClass *klass) @@ -9301,7 +9546,7 @@ mono_class_is_delegate (MonoClass *klass) * @klass: The MonoClass to act on * @interface: The interface to check if @klass implements. * - * Returns: true if @klass implements @interface. + * Returns: TRUE if @klass implements @interface. */ mono_bool mono_class_implements_interface (MonoClass* klass, MonoClass* iface) @@ -9313,7 +9558,7 @@ mono_class_implements_interface (MonoClass* klass, MonoClass* iface) * mono_field_get_name: * @field: the MonoClassField to act on * - * Returns: the name of the field. + * Returns: The name of the field. */ const char* mono_field_get_name (MonoClassField *field) @@ -9375,7 +9620,7 @@ mono_field_get_parent (MonoClassField *field) * The metadata flags for a field are encoded using the * FIELD_ATTRIBUTE_* constants. See the tabledefs.h file for details. * - * Returns: the flags for the field. + * Returns: The flags for the field. */ guint32 mono_field_get_flags (MonoClassField *field) @@ -9386,10 +9631,10 @@ mono_field_get_flags (MonoClassField *field) } /** - * mono_field_get_offset; + * mono_field_get_offset: * @field: the MonoClassField to act on * - * Returns: the field offset. + * Returns: The field offset. */ guint32 mono_field_get_offset (MonoClassField *field) @@ -9410,7 +9655,7 @@ mono_field_get_rva (MonoClassField *field) if (!klass->ext || !klass->ext->field_def_values) { mono_class_alloc_ext (klass); - field_def_values = mono_class_alloc0 (klass, sizeof (MonoFieldDefaultValue) * klass->field.count); + field_def_values = (MonoFieldDefaultValue *)mono_class_alloc0 (klass, sizeof (MonoFieldDefaultValue) * klass->field.count); mono_image_lock (klass->image); if (!klass->ext->field_def_values) @@ -9431,10 +9676,10 @@ mono_field_get_rva (MonoClassField *field) } /** - * mono_field_get_data; + * mono_field_get_data: * @field: the MonoClassField to act on * - * Returns: pointer to the metadata constant value or to the field + * Returns: A pointer to the metadata constant value or to the field * data if it has an RVA flag. */ const char * @@ -9455,7 +9700,7 @@ mono_field_get_data (MonoClassField *field) * mono_property_get_name: * @prop: the MonoProperty to act on * - * Returns: the name of the property + * Returns: The name of the property */ const char* mono_property_get_name (MonoProperty *prop) @@ -9467,7 +9712,7 @@ mono_property_get_name (MonoProperty *prop) * mono_property_get_set_method * @prop: the MonoProperty to act on. * - * Returns: the setter method of the property (A MonoMethod) + * Returns: The setter method of the property (A MonoMethod) */ MonoMethod* mono_property_get_set_method (MonoProperty *prop) @@ -9479,7 +9724,7 @@ mono_property_get_set_method (MonoProperty *prop) * mono_property_get_get_method * @prop: the MonoProperty to act on. * - * Returns: the setter method of the property (A MonoMethod) + * Returns: The setter method of the property (A MonoMethod) */ MonoMethod* mono_property_get_get_method (MonoProperty *prop) @@ -9491,7 +9736,7 @@ mono_property_get_get_method (MonoProperty *prop) * mono_property_get_parent: * @prop: the MonoProperty to act on. * - * Returns: the MonoClass where the property was defined. + * Returns: The MonoClass where the property was defined. */ MonoClass* mono_property_get_parent (MonoProperty *prop) @@ -9506,7 +9751,7 @@ mono_property_get_parent (MonoProperty *prop) * The metadata flags for a property are encoded using the * PROPERTY_ATTRIBUTE_* constants. See the tabledefs.h file for details. * - * Returns: the flags for the property. + * Returns: The flags for the property. */ guint32 mono_property_get_flags (MonoProperty *prop) @@ -9518,7 +9763,7 @@ mono_property_get_flags (MonoProperty *prop) * mono_event_get_name: * @event: the MonoEvent to act on * - * Returns: the name of the event. + * Returns: The name of the event. */ const char* mono_event_get_name (MonoEvent *event) @@ -9530,7 +9775,7 @@ mono_event_get_name (MonoEvent *event) * mono_event_get_add_method: * @event: The MonoEvent to act on. * - * Returns: the @add' method for the event (a MonoMethod). + * Returns: The @add' method for the event (a MonoMethod). */ MonoMethod* mono_event_get_add_method (MonoEvent *event) @@ -9542,7 +9787,7 @@ mono_event_get_add_method (MonoEvent *event) * mono_event_get_remove_method: * @event: The MonoEvent to act on. * - * Returns: the @remove method for the event (a MonoMethod). + * Returns: The @remove method for the event (a MonoMethod). */ MonoMethod* mono_event_get_remove_method (MonoEvent *event) @@ -9554,7 +9799,7 @@ mono_event_get_remove_method (MonoEvent *event) * mono_event_get_raise_method: * @event: The MonoEvent to act on. * - * Returns: the @raise method for the event (a MonoMethod). + * Returns: The @raise method for the event (a MonoMethod). */ MonoMethod* mono_event_get_raise_method (MonoEvent *event) @@ -9566,7 +9811,7 @@ mono_event_get_raise_method (MonoEvent *event) * mono_event_get_parent: * @event: the MonoEvent to act on. * - * Returns: the MonoClass where the event is defined. + * Returns: The MonoClass where the event is defined. */ MonoClass* mono_event_get_parent (MonoEvent *event) @@ -9581,7 +9826,7 @@ mono_event_get_parent (MonoEvent *event) * The metadata flags for an event are encoded using the * EVENT_* constants. See the tabledefs.h file for details. * - * Returns: the flags for the event. + * Returns: The flags for the event. */ guint32 mono_event_get_flags (MonoEvent *event) @@ -9617,7 +9862,7 @@ find_method_in_metadata (MonoClass *klass, const char *name, int param_count, in MonoMethod *method; MonoMethodSignature *sig; - /* class->method.first points into the methodptr table */ + /* klass->method.first points into the methodptr table */ mono_metadata_decode_table_row (klass->image, MONO_TABLE_METHOD, klass->method.first + i, cols, MONO_METHOD_SIZE); if (!strcmp (mono_metadata_string_heap (klass->image, cols [MONO_METHOD_NAME]), name)) { @@ -9668,7 +9913,8 @@ mono_class_get_method_from_name_flags (MonoClass *klass, const char *name, int p if (res) { MonoError error; res = mono_class_inflate_generic_method_full_checked (res, klass, mono_class_get_context (klass), &error); - g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/ + if (!mono_error_ok (&error)) + mono_error_cleanup (&error); /*FIXME don't swallow the error */ } return res; } @@ -9715,7 +9961,7 @@ mono_class_get_method_from_name_flags (MonoClass *klass, const char *name, int p gboolean mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data) { - if (klass->exception_type) + if (mono_class_has_failure (klass)) return FALSE; mono_loader_lock (); @@ -9748,7 +9994,7 @@ mono_class_get_exception_data (MonoClass *klass) void mono_classes_init (void) { - mono_mutex_init (&classes_mutex); + mono_os_mutex_init (&classes_mutex); mono_counters_register ("Inflated methods size", MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &inflated_methods_size); @@ -9773,7 +10019,7 @@ mono_classes_cleanup (void) if (global_interface_bitset) mono_bitset_free (global_interface_bitset); global_interface_bitset = NULL; - mono_mutex_destroy (&classes_mutex); + mono_os_mutex_destroy (&classes_mutex); } /** @@ -9789,7 +10035,7 @@ mono_class_get_exception_for_failure (MonoClass *klass) { gpointer exception_data = mono_class_get_exception_data (klass); - switch (klass->exception_type) { + switch (mono_class_get_failure(klass)) { case MONO_EXCEPTION_TYPE_LOAD: { MonoString *name; MonoException *ex; @@ -9802,19 +10048,19 @@ mono_class_get_exception_for_failure (MonoClass *klass) return ex; } case MONO_EXCEPTION_MISSING_METHOD: { - char *class_name = exception_data; + char *class_name = (char *)exception_data; char *assembly_name = class_name + strlen (class_name) + 1; return mono_get_exception_missing_method (class_name, assembly_name); } case MONO_EXCEPTION_MISSING_FIELD: { - char *class_name = exception_data; + char *class_name = (char *)exception_data; char *member_name = class_name + strlen (class_name) + 1; return mono_get_exception_missing_field (class_name, member_name); } case MONO_EXCEPTION_FILE_NOT_FOUND: { - char *msg_format = exception_data; + char *msg_format = (char *)exception_data; char *assembly_name = msg_format + strlen (msg_format) + 1; char *msg = g_strdup_printf (msg_format, assembly_name); MonoException *ex; @@ -9826,7 +10072,7 @@ mono_class_get_exception_for_failure (MonoClass *klass) return ex; } case MONO_EXCEPTION_BAD_IMAGE: { - return mono_get_exception_bad_image_format (exception_data); + return mono_get_exception_bad_image_format ((const char *)exception_data); } default: { MonoLoaderError *error; @@ -9931,16 +10177,16 @@ can_access_internals (MonoAssembly *accessing, MonoAssembly* accessed) mono_assembly_load_friends (accessed); for (tmp = accessed->friend_assembly_names; tmp; tmp = tmp->next) { - MonoAssemblyName *friend = tmp->data; + MonoAssemblyName *friend_ = (MonoAssemblyName *)tmp->data; /* Be conservative with checks */ - if (!friend->name) + if (!friend_->name) continue; - if (strcmp (accessing->aname.name, friend->name)) + if (strcmp (accessing->aname.name, friend_->name)) continue; - if (friend->public_key_token [0]) { + if (friend_->public_key_token [0]) { if (!accessing->aname.public_key_token [0]) continue; - if (!mono_public_tokens_are_equal (friend->public_key_token, accessing->aname.public_key_token)) + if (!mono_public_tokens_are_equal (friend_->public_key_token, accessing->aname.public_key_token)) continue; } return TRUE; @@ -10108,6 +10354,16 @@ can_access_member (MonoClass *access_klass, MonoClass *member_klass, MonoClass* return FALSE; } +/** + * mono_method_can_access_field: + * @method: Method that will attempt to access the field + * @field: the field to access + * + * Used to determine if a method is allowed to access the specified field. + * + * Returns: TRUE if the given @method is allowed to access the @field while following + * the accessibility rules of the CLI. + */ gboolean mono_method_can_access_field (MonoMethod *method, MonoClassField *field) { @@ -10125,6 +10381,16 @@ mono_method_can_access_field (MonoMethod *method, MonoClassField *field) return can; } +/** + * mono_method_can_access_method: + * @method: Method that will attempt to access the other method + * @called: the method that we want to probe for accessibility. + * + * Used to determine if the @method is allowed to access the specified @called method. + * + * Returns: TRUE if the given @method is allowed to invoke the @called while following + * the accessibility rules of the CLI. + */ gboolean mono_method_can_access_method (MonoMethod *method, MonoMethod *called) { @@ -10351,11 +10617,11 @@ mono_generic_class_is_generic_type_definition (MonoGenericClass *gklass) * LOCKING: Acquires the loader lock. */ void -mono_class_setup_interface_id (MonoClass *class) +mono_class_setup_interface_id (MonoClass *klass) { mono_loader_lock (); - if (MONO_CLASS_IS_INTERFACE (class) && !class->interface_id) - class->interface_id = mono_get_unique_iid (class); + if (MONO_CLASS_IS_INTERFACE (klass) && !klass->interface_id) + klass->interface_id = mono_get_unique_iid (klass); mono_loader_unlock (); } @@ -10372,7 +10638,7 @@ mono_class_alloc_ext (MonoClass *klass) if (klass->ext) return; - ext = mono_class_alloc0 (klass, sizeof (MonoClassExt)); + ext = (MonoClassExt *)mono_class_alloc0 (klass, sizeof (MonoClassExt)); mono_image_lock (klass->image); mono_memory_barrier (); if (!klass->ext) @@ -10384,7 +10650,7 @@ mono_class_alloc_ext (MonoClass *klass) /* * mono_class_setup_interfaces: * - * Initialize class->interfaces/interfaces_count. + * Initialize klass->interfaces/interfaces_count. * LOCKING: Acquires the loader lock. * This function can fail the type. */ @@ -10404,7 +10670,7 @@ mono_class_setup_interfaces (MonoClass *klass, MonoError *error) /* generic IList, ICollection, IEnumerable */ interface_count = mono_defaults.generic_ireadonlylist_class ? 2 : 1; - interfaces = mono_image_alloc0 (klass->image, sizeof (MonoClass*) * interface_count); + interfaces = (MonoClass **)mono_image_alloc0 (klass->image, sizeof (MonoClass*) * interface_count); args [0] = &klass->element_class->byval_arg; interfaces [0] = mono_class_bind_generic_parameters ( @@ -10452,10 +10718,10 @@ mono_class_setup_interfaces (MonoClass *klass, MonoError *error) static void mono_field_resolve_type (MonoClassField *field, MonoError *error) { - MonoClass *class = field->parent; - MonoImage *image = class->image; - MonoClass *gtd = class->generic_class ? mono_class_get_generic_type_definition (class) : NULL; - int field_idx = field - class->fields; + MonoClass *klass = field->parent; + MonoImage *image = klass->image; + MonoClass *gtd = klass->generic_class ? mono_class_get_generic_type_definition (klass) : NULL; + int field_idx = field - klass->fields; mono_error_init (error); @@ -10464,38 +10730,36 @@ mono_field_resolve_type (MonoClassField *field, MonoError *error) MonoType *gtype = mono_field_get_type_checked (gfield, error); if (!mono_error_ok (error)) { char *err_msg = g_strdup_printf ("Could not load field %d type due to: %s", field_idx, mono_error_get_message (error)); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, err_msg); - g_free (err_msg); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg); } - field->type = mono_class_inflate_generic_type_no_copy (image, gtype, mono_class_get_context (class), error); + field->type = mono_class_inflate_generic_type_no_copy (image, gtype, mono_class_get_context (klass), error); if (!mono_error_ok (error)) { char *err_msg = g_strdup_printf ("Could not load field %d type due to: %s", field_idx, mono_error_get_message (error)); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, err_msg); - g_free (err_msg); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg); } } else { const char *sig; guint32 cols [MONO_FIELD_SIZE]; MonoGenericContainer *container = NULL; - int idx = class->field.first + field_idx; + int idx = klass->field.first + field_idx; /*FIXME, in theory we do not lazy load SRE fields*/ g_assert (!image_is_dynamic (image)); - if (class->generic_container) { - container = class->generic_container; + if (klass->generic_container) { + container = klass->generic_container; } else if (gtd) { container = gtd->generic_container; g_assert (container); } - /* class->field.first and idx points into the fieldptr table */ + /* klass->field.first and idx points into the fieldptr table */ mono_metadata_decode_table_row (image, MONO_TABLE_FIELD, idx, cols, MONO_FIELD_SIZE); if (!mono_verifier_verify_field_signature (image, cols [MONO_FIELD_SIGNATURE], NULL)) { - mono_error_set_type_load_class (error, class, "Could not verify field %s signature", field->name); - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); + mono_error_set_type_load_class (error, klass, "Could not verify field %s signature", field->name);; + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup (mono_error_get_message (error))); return; } @@ -10504,26 +10768,29 @@ mono_field_resolve_type (MonoClassField *field, MonoError *error) mono_metadata_decode_value (sig, &sig); /* FIELD signature == 0x06 */ g_assert (*sig == 0x06); - field->type = mono_metadata_parse_type_full (image, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig); - if (!field->type) - mono_class_set_failure_from_loader_error (class, error, g_strdup_printf ("Could not load field %s type", field->name)); + + field->type = mono_metadata_parse_type_checked (image, container, cols [MONO_FIELD_FLAGS], FALSE, sig + 1, &sig, error); + if (!field->type) { + char *err_msg = g_strdup_printf ("Could not load field %d type due to: %s", field_idx, mono_error_get_message (error)); + mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg); + } } } static guint32 mono_field_resolve_flags (MonoClassField *field) { - MonoClass *class = field->parent; - MonoImage *image = class->image; - MonoClass *gtd = class->generic_class ? mono_class_get_generic_type_definition (class) : NULL; - int field_idx = field - class->fields; + MonoClass *klass = field->parent; + MonoImage *image = klass->image; + MonoClass *gtd = klass->generic_class ? mono_class_get_generic_type_definition (klass) : NULL; + int field_idx = field - klass->fields; if (gtd) { MonoClassField *gfield = >d->fields [field_idx]; return mono_field_get_flags (gfield); } else { - int idx = class->field.first + field_idx; + int idx = klass->field.first + field_idx; /*FIXME, in theory we do not lazy load SRE fields*/ g_assert (!image_is_dynamic (image)); @@ -10536,14 +10803,14 @@ mono_field_resolve_flags (MonoClassField *field) * mono_class_setup_basic_field_info: * @class: The class to initialize * - * Initializes the class->fields array of fields. + * Initializes the klass->fields array of fields. * Aquires the loader lock. */ static void -mono_class_setup_basic_field_info_locking (MonoClass *class) +mono_class_setup_basic_field_info_locking (MonoClass *klass) { mono_loader_lock (); - mono_class_setup_basic_field_info (class); + mono_class_setup_basic_field_info (klass); mono_loader_unlock (); } @@ -10573,16 +10840,18 @@ mono_class_get_fields_lazy (MonoClass* klass, gpointer *iter) return NULL; /* start from the first */ if (klass->field.count) { - return *iter = &klass->fields [0]; + *iter = &klass->fields [0]; + return (MonoClassField *)*iter; } else { /* no fields */ return NULL; } } - field = *iter; + field = (MonoClassField *)*iter; field++; if (field < &klass->fields [klass->field.count]) { - return *iter = field; + *iter = field; + return (MonoClassField *)*iter; } return NULL; } @@ -10593,3 +10862,5 @@ mono_class_full_name (MonoClass *klass) return mono_type_full_name (&klass->byval_arg); } +/* Declare all shared lazy type lookup functions */ +GENERATE_TRY_GET_CLASS_WITH_CACHE (safehandle, System.Runtime.InteropServices, SafeHandle)