#include <mono/metadata/image.h>
#include <mono/metadata/loader.h>
-#define MONO_CLASS_IS_ARRAY(c) (c->type_token == 0)
+#define MONO_CLASS_IS_ARRAY(c) ((c)->rank)
-#define MONO_CLASS_STATIC_FIELDS_BASE(c) (c->data)
+extern gboolean mono_print_vtable;
typedef struct {
MonoType *type;
guint32 attrs;
} MonoProperty;
+typedef struct {
+ const char *name;
+ MonoMethod *add;
+ MonoMethod *remove;
+ MonoMethod *raise;
+ MonoMethod **other;
+ guint32 attrs;
+} MonoEvent;
+
struct _MonoClass {
MonoImage *image;
guint32 type_token;
guint dummy : 1; /* temorary hack */
guint inited : 1;
+
+ /* We use init_pending to detect cyclic calls to mono_class_init */
+ guint init_pending : 1;
+
+ /* A class contains static and non static data. Static data can be
+ * of the same type as the class itselfs, but it does not influence
+ * the instance size of the class. To avoid cyclic calls to
+ * mono_class_init (from mono_class_instance_size ()) we first
+ * initialise all non static fields. After that we set size_inited
+ * to 1, because we know the instance size now. After that we
+ * initialise all static fields.
+ */
+ guint size_inited : 1;
guint valuetype : 1; /* derives from System.ValueType */
guint enumtype : 1; /* derives from System.Enum */
+ guint ghcimpl : 1; /* class has its own GetHashCode impl */
+ guint marshalbyref : 1; /* class is a MarshalByRefObject */
+ guint contextbound : 1; /* class is a ContextBoundObject */
+ guint delegate : 1; /* class is a Delegate */
guint min_align : 4;
MonoClass *parent;
const char *name;
const char *name_space;
- guint interface_id; /* unique inderface id (for interfaces) */
- guint max_interface_id;
- gpointer *interface_offsets;
guint interface_count;
+ guint interface_id; /* unique inderface id (for interfaces) */
+ guint max_interface_id;
+ gint *interface_offsets;
MonoClass **interfaces;
/*
struct {
guint32 first, last;
int count;
- } field, method, property;
+ } field, method, property, event;
/*
* Field information: Type and location from object base
MonoClassField *fields;
MonoProperty *properties;
+
+ MonoEvent *events;
MonoMethod **methods;
/* used as the type of the this argument and when passing the arg by value */
MonoType this_arg;
MonoType byval_arg;
-
- gpointer data;
- gpointer vtable [0];
+ void *reflection_info;
+
+ MonoMethod **vtable;
};
+typedef struct {
+ MonoClass *klass;
+ MonoDomain *domain; /* each object/vtable belongs to exactly one domain */
+ guint max_interface_id;
+ gpointer *interface_offsets;
+ gpointer data;
+ gpointer vtable [0];
+} MonoVTable;
+
+
typedef gpointer (*MonoTrampoline) (MonoMethod *method);
-typedef void (*MonoRuntimeClassInit) (MonoClass *klass);
MonoClass *
mono_class_get (MonoImage *image, guint32 type_token);
void
mono_class_init (MonoClass *klass);
+MonoVTable *
+mono_class_vtable (MonoDomain *domain, MonoClass *class);
+
+MonoVTable *
+mono_class_proxy_vtable (MonoDomain *domain, MonoClass *class);
+
+void
+mono_class_setup_mono_type (MonoClass *class);
+
+void
+mono_class_setup_parent (MonoClass *class, MonoClass *parent);
+
MonoClass *
mono_class_from_name (MonoImage *image, const char* name_space, const char *name);
mono_field_from_memberref (MonoImage *image, guint32 token, MonoClass **retklass);
MonoClass *
-mono_array_class_get (MonoClass *eclass, guint32 rank);
+mono_array_class_get (MonoType *element_type, guint32 rank);
+
+MonoClass *
+mono_ptr_class_get (MonoType *type);
MonoClassField *
mono_class_get_field (MonoClass *klass, guint32 field_token);
mono_install_trampoline (MonoTrampoline func);
void
-mono_install_runtime_class_init (MonoRuntimeClassInit func);
+mono_install_remoting_trampoline (MonoTrampoline func);
#endif /* _MONO_CLI_CLASS_H_ */