Author: urs
Date: 2005-04-16 02:36:08 -0400 (Sat, 16 Apr 2005)
New Revision: 43088
Modified:
trunk/objc-sharp/autogen.sh
trunk/objc-sharp/src/CocoaMono.h
trunk/objc-sharp/src/MonoHelper.c
Log:
Make MonoHelper.c compile
Modified: trunk/objc-sharp/autogen.sh
===================================================================
--- trunk/objc-sharp/autogen.sh 2005-04-15 23:52:21 UTC (rev 43087)
+++ trunk/objc-sharp/autogen.sh 2005-04-16 06:36:08 UTC (rev 43088)
@@ -1,4 +1,4 @@
-aclocal
+aclocal $ACLOCAL_FLAGS
libtoolize --force --copy
automake -a
autoconf
Modified: trunk/objc-sharp/src/CocoaMono.h
===================================================================
--- trunk/objc-sharp/src/CocoaMono.h 2005-04-15 23:52:21 UTC (rev 43087)
+++ trunk/objc-sharp/src/CocoaMono.h 2005-04-16 06:36:08 UTC (rev 43088)
@@ -13,9 +13,11 @@
#ifdef __OBJC__
#include <objc/objc.h>
+#else
+typedef int BOOL;
#endif
-#include <crt_externs.h>
+//#include <crt_externs.h>
#define environ (* _NSGetEnviron())
#ifndef AUTORELEASE
Modified: trunk/objc-sharp/src/MonoHelper.c
===================================================================
--- trunk/objc-sharp/src/MonoHelper.c 2005-04-15 23:52:21 UTC (rev 43087)
+++ trunk/objc-sharp/src/MonoHelper.c 2005-04-16 06:36:08 UTC (rev 43088)
@@ -6,7 +6,21 @@
*
* $Header:
/home/miguel/third-conversion/public/objc-sharp/src/MonoHelper.c,v 1.3
2004/06/01 23:28:05 urs Exp $
*/
+#ifndef _WIN32
#include <crt_externs.h>
+#else
+void exit(int);
+void g_error(const char *, int);
+typedef int gint;
+typedef float gfloat;
+typedef double gdouble;
+typedef __int64 gint64;
+typedef unsigned __int64 guint64;
+typedef void* GModule;
+typedef void* GHashTable;
+#define NO 0
+#define YES 1
+#endif
#define environ (* _NSGetEnviron())
#define JIT 1
@@ -18,12 +32,232 @@
#endif
#include <mono/metadata/environment.h>
#include <mono/metadata/assembly.h>
-#include <mono/metadata/tabledefs.h>
#include <mono/metadata/tokentype.h>
#include <mono/metadata/class.h>
#include <mono/metadata/object.h>
#include <mono/metadata/loader.h>
+enum {
+ FILE_CONTAINS_METADATA = 0,
+ FILE_CONTAINS_NO_METADATA = 1
+};
+#define METHOD_ATTRIBUTE_STATIC 0x0010
+#define FIELD_ATTRIBUTE_STATIC 0x0010
+#define TYPE_ATTRIBUTE_VISIBILITY_MASK 0x00000007
+#define TYPE_ATTRIBUTE_PUBLIC 0x00000001
+#define TYPE_ATTRIBUTE_NESTED_PUBLIC 0x00000002
+#define METHOD_ATTRIBUTE_SPECIAL_NAME 0x0800
+#define PARAM_ATTRIBUTE_IN 0x0001
+#define PARAM_ATTRIBUTE_OUT 0x0002
+typedef struct _MonoReflectionType {
+ MonoObject object;
+ MonoType *type;
+} _MonoReflectionType;
+typedef struct _MonoAssembly {
+ int ref_count;
+ char *basedir;
+ MonoAssemblyName aname;
+ GModule *aot_module;
+ MonoImage *image;
+ guint8 in_gac;
+ guint8 dynamic;
+ guint8 corlib_internal;
+ gboolean ref_only;
+ /* security manager flags (one bit is for lazy initialization) */
+ guint32 ecma:2; /* Has the ECMA key */
+ guint32 aptc:2; /* Has the [AllowPartiallyTrustedCallers]
attributes */
+ guint32 fulltrust:2; /* Has FullTrust permission */
+ guint32 unmanaged:2; /* Has SecurityPermissionFlag.UnmanagedCode
permission */
+} _MonoAssembly;
+typedef struct {
+ const char* data;
+ guint32 size;
+} MonoStreamHeader;
+typedef struct _MonoTableInfo {
+ const char *base;
+ guint rows : 24;
+ guint row_size : 8;
+
+ /*
+ * Tables contain up to 9 columns and the possible sizes of the
+ * fields in the documentation are 1, 2 and 4 bytes. So we
+ * can encode in 2 bits the size.
+ *
+ * A 32 bit value can encode the resulting size
+ *
+ * The top eight bits encode the number of columns in the table.
+ * we only need 4, but 8 is aligned no shift required.
+ */
+ guint32 size_bitfield;
+} _MonoTableInfo;
+typedef struct _MonoImage {
+ int ref_count;
+ FILE *file_descr;
+ /* if file_descr is NULL the image was loaded from raw data */
+ char *raw_data;
+ guint32 raw_data_len;
+ guint8 raw_data_allocated;
+
+ /* Whenever this is a dynamically emitted module */
+ guint8 dynamic;
+
+ char *name;
+ const char *assembly_name;
+ const char *module_name;
+ const char *version;
+ char *guid;
+ void *image_info;
+ MonoMemPool *mempool;
+
+ char *raw_metadata;
+
+ guint8 idx_string_wide, idx_guid_wide, idx_blob_wide;
+
+ MonoStreamHeader heap_strings;
+ MonoStreamHeader heap_us;
+ MonoStreamHeader heap_blob;
+ MonoStreamHeader heap_guid;
+ MonoStreamHeader heap_tables;
+
+ const char *tables_base;
+
+ /**/
+ _MonoTableInfo tables [MONO_TABLE_NUM];
+
+ /*
+ * references is initialized only by using the mono_assembly_open
+ * function, and not by using the lowlevel mono_image_open.
+ *
+ * It is NULL terminated.
+ */
+ MonoAssembly **references;
+
+ MonoImage **modules;
+ guint32 module_count;
+
+ MonoImage **files;
+
+ /*
+ * The Assembly this image was loaded from.
+ */
+ MonoAssembly *assembly;
+
+ /*
+ * Indexed by method tokens and typedef tokens.
+ */
+ GHashTable *method_cache;
+ GHashTable *class_cache;
+ /*
+ * Indexed by fielddef and memberref tokens
+ */
+ GHashTable *field_cache;
+
+ /* indexed by typespec tokens. */
+ GHashTable *typespec_cache;
+ /* indexed by token */
+ GHashTable *memberref_signatures;
+ GHashTable *helper_signatures;
+
+ /*
+ * Indexes namespaces to hash tables that map class name to typedef
token.
+ */
+ GHashTable *name_cache;
+
+ /*
+ * Indexed by ((rank << 24) | (typedef & 0xffffff)), which limits us to
a
+ * maximal rank of 255
+ */
+ GHashTable *array_cache;
+
+ /*
+ * indexed by MonoMethodSignature
+ */
+ GHashTable *delegate_begin_invoke_cache;
+ GHashTable *delegate_end_invoke_cache;
+ GHashTable *delegate_invoke_cache;
+
+ /*
+ * indexed by MonoMethod pointers
+ */
+ GHashTable *runtime_invoke_cache;
+ GHashTable *managed_wrapper_cache;
+ GHashTable *native_wrapper_cache;
+ GHashTable *remoting_invoke_cache;
+ GHashTable *synchronized_cache;
+ GHashTable *unbox_wrapper_cache;
+
+ void *reflection_info;
+
+ /*
+ * user_info is a public field and is not touched by the
+ * metadata engine
+ */
+ void *user_info;
+
+ /* dll map entries */
+ GHashTable *dll_map;
+} _MonoImage;
+typedef struct _MonoReflectionMethod {
+ MonoObject object;
+ MonoMethod *method;
+ MonoString *name;
+ MonoReflectionType *reftype;
+} _MonoReflectionMethod;
+typedef struct {
+ MonoImage *corlib;
+ MonoClass *object_class;
+ MonoClass *byte_class;
+ MonoClass *void_class;
+ MonoClass *boolean_class;
+ MonoClass *sbyte_class;
+ MonoClass *int16_class;
+ MonoClass *uint16_class;
+ MonoClass *int32_class;
+ MonoClass *uint32_class;
+ MonoClass *int_class;
+ MonoClass *uint_class;
+ MonoClass *int64_class;
+ MonoClass *uint64_class;
+ MonoClass *single_class;
+ MonoClass *double_class;
+ MonoClass *char_class;
+ MonoClass *string_class;
+ MonoClass *enum_class;
+ MonoClass *array_class;
+ MonoClass *delegate_class;
+ MonoClass *multicastdelegate_class;
+ MonoClass *asyncresult_class;
+ MonoClass *waithandle_class;
+ MonoClass *typehandle_class;
+ MonoClass *fieldhandle_class;
+ MonoClass *methodhandle_class;
+ MonoClass *monotype_class;
+ MonoClass *exception_class;
+ MonoClass *threadabortexception_class;
+ MonoClass *thread_class;
+ MonoClass *transparent_proxy_class;
+ MonoClass *real_proxy_class;
+ MonoClass *mono_method_message_class;
+ MonoClass *appdomain_class;
+ MonoClass *field_info_class;
+ MonoClass *method_info_class;
+ MonoClass *stringbuilder_class;
+ MonoClass *math_class;
+ MonoClass *stack_frame_class;
+ MonoClass *stack_trace_class;
+ MonoClass *marshal_class;
+ MonoClass *iserializeable_class;
+ MonoClass *serializationinfo_class;
+ MonoClass *streamingcontext_class;
+ MonoClass *typed_reference_class;
+ MonoClass *argumenthandle_class;
+ MonoClass *marshalbyrefobject_class;
+ MonoClass *monitor_class;
+ MonoClass *iremotingtypeinfo_class;
+ MonoClass *runtimesecurityframe_class;
+} MonoDefaults;
+extern MonoDefaults mono_defaults;
+
#include "CocoaMono.h"
#include <string.h>
@@ -114,29 +348,23 @@
return retval;
}
+static MonoMethodSignature* _mono_method_get_signature(MonoMethod* method_) {
+ typedef struct _MonoMethod {
+ guint16 flags; /* method flags */
+ guint16 iflags; /* method implementation flags */
+ guint32 token;
+ MonoClass *klass;
+ MonoMethodSignature *signature;
+ } _MonoMethod;
+
+ _MonoMethod* method = (_MonoMethod*)method_;
+ return method->signature;
+}
+
static MonoMethod *
mono_find_method_by_name (MonoClass *klass, const char *name, int param_count)
{
- MonoMethod *res = NULL;
- int i;
-
- while (klass != NULL)
- {
- for (i = 0; i < klass->method.count; ++i) {
- if (klass->methods[i]->name[0] == name[0] &&
- strcmp(name, klass->methods[i]->name) == 0 &&
- klass->methods[i]->signature->param_count ==
param_count)
- {
- res = klass->methods[i];
- break;
- }
- }
- if (res != NULL)
- break;
- klass = klass->parent;
- }
-
- return res;
+ return mono_class_get_method_from_name_flags(klass, name, param_count,
0);
}
static gboolean
@@ -144,20 +372,21 @@
{
MonoMethod *method;
- method = prop->get;
+ method = mono_property_get_get_method(prop);
if (!method)
- method = prop->set;
+ method = mono_property_get_set_method(prop);
- return method->flags & METHOD_ATTRIBUTE_STATIC;
+ return mono_method_get_flags(method, NULL) & METHOD_ATTRIBUTE_STATIC;
}
static void
mono_field_set_value_object(MonoClass *klass,MonoClassField *field, MonoObject
*obj, MonoObject *value)
{
gchar *v = (gchar *) value;
-
- if (!field->type->byref) {
- switch (field->type->type) {
+ MonoType* type = mono_field_get_type(field);
+
+ if (!type->byref) {
+ switch (type->type) {
case MONO_TYPE_U1:
case MONO_TYPE_I1:
case MONO_TYPE_BOOLEAN:
@@ -184,16 +413,18 @@
break;
default:
g_error ("type 0x%x not handled in "
-
"ves_icall_FieldInfo_SetValueInternal", field->type->type);
+
"ves_icall_FieldInfo_SetValueInternal", type->type);
return;
}
}
- if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
+ if (type->attrs & FIELD_ATTRIBUTE_STATIC) {
MonoVTable *vtable = mono_class_vtable (mono_domain_get(), klass);
+#if false
if (!vtable->initialized)
mono_runtime_class_init(vtable);
+#endif
mono_field_static_set_value(vtable, field, v);
} else {
mono_field_set_value(obj, field, v);
@@ -201,11 +432,12 @@
}
static MonoArray*
-mono_module_get_types (MonoDomain *domain, MonoImage *image,
+mono_module_get_types (MonoDomain *domain, MonoImage *image_,
MonoBoolean exportedOnly)
{
MonoArray *res;
MonoClass *klass;
+ _MonoImage *image = (_MonoImage*)image_;
MonoTableInfo *tdef = &image->tables[MONO_TABLE_TYPEDEF];
int i, count;
guint32 attrs, visibility;
@@ -229,7 +461,7 @@
visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK;
if (!exportedOnly || (visibility == TYPE_ATTRIBUTE_PUBLIC ||
visibility == TYPE_ATTRIBUTE_NESTED_PUBLIC)) {
klass = mono_class_get(image, (i + 1) | MONO_TOKEN_TYPE_DEF);
- mono_array_set(res, gpointer, count, mono_type_get_object(domain,
&klass->byval_arg));
+ mono_array_set(res, gpointer, count, mono_type_get_object(domain,
mono_class_get_type(klass)));
count++;
}
}
@@ -237,11 +469,13 @@
return res;
}
+
// Helper functions
void NSArrayAddRange(NSArrayRef array,MonoArray* monoArray)
{
guint32 i, length = mono_array_length(monoArray);
- MonoClass *klass = mono_object_class(monoArray)->element_class;
+ MonoClass *klass = mono_object_get_class((MonoObject*)monoArray);
+ klass = mono_class_get_element_class(klass);
for (i = 0; i < length; ++i)
{
@@ -311,12 +545,14 @@
NSObjectRef Mono2ObjC(MonoObjectRef _arg)
{
+ MonoObject *arg = (MonoObject*)_arg;
+ MonoClass *klass;
+
if (_arg == NULL)
return NULL;
- MonoObject *arg = (MonoObject*)_arg;
- MonoClass *klass = mono_object_class(arg);
-
+ klass = mono_object_get_class(arg);
+
if (klass == mono_defaults.void_class)
return NULL;
else if (klass == mono_defaults.byte_class)
@@ -352,7 +588,7 @@
else if (klass == mono_defaults.enum_class)
return NSNumberFromInt(*(gint*)mono_object_unbox(arg));
else if (klass == mono_defaults.array_class
- || (klass->rank != 0)
+ || (mono_class_get_rank(klass) != 0)
)
{
NSArrayRef array = NSArrayNew();
@@ -362,8 +598,9 @@
}
else if (klass == mono_defaults.monotype_class)
{
- MonoReflectionType *typeArg = (MonoReflectionType*)arg;
- MonoClass *klassArg = mono_class_from_mono_type(typeArg->type);
+ _MonoReflectionType *typeArg = (_MonoReflectionType*)arg;
+ MonoType *type = typeArg->type;
+ MonoClass *klassArg = mono_class_from_mono_type(type);
return MonoKlass2ObjC(klassArg);
}
@@ -383,16 +620,19 @@
MonoClassRef MonoAssemblyFindClass(MonoAssemblyRef _assembly,const char*name)
{
+ MonoAssembly *assembly = (MonoAssembly*)_assembly;
+ char *tmpName;
+ MonoType *type;
+ MonoClass *klass;
+
if (_assembly == NULL)
return NULL;
- MonoAssembly *assembly = (MonoAssembly*)_assembly;
-
- char *tmpName = (char*)malloc(strlen(name)+1);
+ tmpName = (char*)malloc(strlen(name)+1);
strcpy(tmpName,name);
- MonoType *type = mono_reflection_type_from_name(tmpName,
assembly->image);
- MonoClass *klass = type != NULL ? mono_class_from_mono_type(type) :
NULL;
+ type = mono_reflection_type_from_name(tmpName, assembly->image);
+ klass = type != NULL ? mono_class_from_mono_type(type) : NULL;
free(tmpName);
return (MonoClassRef)klass;
@@ -401,15 +641,18 @@
NSArrayRef MonoGetClassNames(MonoAssemblyRef _assembly)
{
NSArrayRef res = NSArrayNew();
+ _MonoAssembly* assembly = (_MonoAssembly*)_assembly;
+ MonoImage *image;
+ MonoTableInfo *table;
+ MonoDomain *domain;
+ int i;
if (_assembly == NULL)
return res;
- MonoAssembly* assembly = (MonoAssembly*)_assembly;
- MonoImage *image = assembly->image;
- MonoTableInfo *table = &image->tables [MONO_TABLE_FILE];
- MonoDomain *domain = mono_domain_get();
- int i;
+ image = assembly->image;
+ table = &image->tables [MONO_TABLE_FILE];
+ domain = mono_domain_get();
NSArrayAddRange(res, mono_module_get_types(domain, image, FALSE));
@@ -435,16 +678,15 @@
if (_klass != NULL)
{
MonoClass *klass = (MonoClass*)_klass;
- int i;
-
- for (i = 0; i < klass->field.count; ++i)
- {
- MonoClassField *field = klass->fields+i;
+ gpointer iter = NULL;
+ MonoClassField *field;
+ while ((field = mono_class_get_fields (klass, &iter))) {
+ MonoType *type = mono_field_get_type(field);
- if (((field->type->attrs & FIELD_ATTRIBUTE_STATIC) !=
0) != (useStatic != 0))
+ if (((type->attrs & FIELD_ATTRIBUTE_STATIC) != 0) !=
(useStatic != 0))
continue;
- NSArrayAddObject(ret,ToNSString(field->name));
+
NSArrayAddObject(ret,ToNSString(mono_field_get_name(field)));
}
}
return ret;
@@ -457,16 +699,13 @@
if (_klass != NULL)
{
MonoClass *klass = (MonoClass*)_klass;
- int i;
-
- for (i = 0; i < klass->property.count; ++i)
- {
- MonoProperty *property = klass->properties+i;
-
+ gpointer iter = NULL;
+ MonoProperty *property;
+ while ((property = mono_class_get_properties (klass, &iter))) {
if ((property_is_static(property) != 0) != (useStatic
!= 0))
continue;
- NSArrayAddObject(ret,ToNSString(property->name));
+
NSArrayAddObject(ret,ToNSString(mono_property_get_name(property)));
}
}
return ret;
@@ -479,22 +718,20 @@
if (_klass != NULL)
{
MonoClass *klass = (MonoClass*)_klass;
- int i;
-
- for (i = 0; i < klass->method.count; ++i)
- {
- MonoMethod *method = klass->methods[i];
- printf("\nMonoHelper MonoGetMethodNames: %s",
method->name);
- if (strcmp(method->name, ".cctor") == 0)
+ gpointer iter = NULL;
+ MonoMethod *method;
+ while ((method = mono_class_get_methods (klass, &iter))) {
+ printf("\nMonoHelper MonoGetMethodNames: %s",
mono_method_get_name(method));
+ if (strcmp(mono_method_get_name(method), ".cctor") == 0)
continue;
- if (method->flags & METHOD_ATTRIBUTE_SPECIAL_NAME)
+ if (mono_method_get_flags(method, NULL) &
METHOD_ATTRIBUTE_SPECIAL_NAME)
continue;
- if (((method->flags & METHOD_ATTRIBUTE_STATIC) != 0) !=
(useStatic != 0))
+ if (((mono_method_get_flags(method, NULL) &
METHOD_ATTRIBUTE_STATIC) != 0) != (useStatic != 0))
continue;
- NSArrayAddObject(ret,ToNSString(method->name));
+
NSArrayAddObject(ret,ToNSString(mono_method_get_name(method)));
}
}
return ret;
@@ -503,7 +740,7 @@
MonoClassRef MonoGetParentClass(MonoClassRef _klass)
{
MonoClass *klass = (MonoClass*)_klass;
- return (MonoClassRef)klass->parent;
+ return (MonoClassRef)mono_class_get_parent(klass);
}
NSArrayRef MonoClassGetInterfaces(MonoClassRef klass)
@@ -518,23 +755,21 @@
if (_klass != NULL)
{
MonoClass *klass = (MonoClass*)_klass;
- int i;
-
- for (i = 0; i < klass->method.count; ++i)
- {
- MonoMethod *method = klass->methods[i];
-
- if (strcmp(method->name, ".cctor") == 0)
+ gpointer iter = NULL;
+ MonoMethod *method;
+ while ((method = mono_class_get_methods (klass, &iter))) {
+ MonoReflectionMethod* refMethod;
+
+ if (strcmp(mono_method_get_name(method), ".cctor") == 0)
continue;
- if (method->flags & METHOD_ATTRIBUTE_SPECIAL_NAME)
+ if (mono_method_get_flags(method, NULL) &
METHOD_ATTRIBUTE_SPECIAL_NAME)
continue;
- if (((method->flags & METHOD_ATTRIBUTE_STATIC) != 0) !=
(useStatic != 0))
+ if (((mono_method_get_flags(method, NULL) &
METHOD_ATTRIBUTE_STATIC) != 0) != (useStatic != 0))
continue;
- MonoReflectionMethod* refMethod =
mono_method_get_object(
- mono_domain_get(), method, klass);
+ refMethod = mono_method_get_object(mono_domain_get(),
method, klass);
NSArrayAddObject(ret,Mono2ObjC((MonoObjectRef)refMethod));
}
}
@@ -548,16 +783,14 @@
if (_klass != NULL)
{
MonoClass *klass = (MonoClass*)_klass;
- int i;
-
- for (i = 0; i < klass->property.count; ++i)
- {
- MonoProperty *property = klass->properties+i;
-
+ gpointer iter = NULL;
+ MonoProperty *property;
+ while ((property = mono_class_get_properties (klass, &iter))) {
+ MonoReflectionProperty* refProp;
if ((property_is_static(property) != 0) != (useStatic
!= 0))
continue;
- MonoReflectionProperty* refProp =
mono_property_get_object(
+ refProp = mono_property_get_object(
mono_domain_get(), klass, property);
NSArrayAddObject(ret,Mono2ObjC((MonoObjectRef)refProp));
}
@@ -572,17 +805,14 @@
if (_klass != NULL)
{
MonoClass *klass = (MonoClass*)_klass;
- int i;
-
- for (i = 0; i < klass->field.count; ++i)
- {
- MonoClassField *field = klass->fields+i;
-
- if (((field->type->attrs & FIELD_ATTRIBUTE_STATIC) !=
0) != (useStatic != 0))
+ gpointer iter = NULL;
+ MonoClassField *field;
+ while ((field = mono_class_get_fields (klass, &iter))) {
+ MonoReflectionField* refField;
+ if (((mono_field_get_type(field)->attrs &
FIELD_ATTRIBUTE_STATIC) != 0) != (useStatic != 0))
continue;
- MonoReflectionField* refField = mono_field_get_object(
- mono_domain_get(), klass, field);
+ refField = mono_field_get_object(mono_domain_get(),
klass, field);
NSArrayAddObject(ret,Mono2ObjC((MonoObjectRef)refField));
}
}
@@ -592,13 +822,13 @@
BOOL MonoClassIsValueType(MonoClassRef _klass)
{
MonoClass *klass = (MonoClass*)_klass;
- return klass->valuetype != 0;
+ return mono_class_is_valuetype(klass) != 0;
}
BOOL MonoClassIsArray(MonoClassRef _klass)
{
MonoClass *klass = (MonoClass*)_klass;
- return klass->rank != 0;
+ return mono_class_get_rank(klass) != 0;
}
BOOL MonoClassIsPrimitive(MonoClassRef _klass)
@@ -632,12 +862,13 @@
NSObjectRef MonoGetFieldValue(MonoClassRef _klass,const char
*name,MonoObjectRef base)
{
+ MonoClass *klass = (MonoClass*)_klass;
+ MonoClassField *field;
+
if (_klass == NULL)
return NULL;
- MonoClass *klass = (MonoClass*)_klass;
- MonoClassField *field = mono_class_get_field_from_name(klass,name);
-
+ field = mono_class_get_field_from_name(klass,name);
if (field == NULL)
return NULL;
@@ -646,17 +877,19 @@
void MonoSetFieldValue(MonoClassRef _klass,const char * name,NSObjectRef
value,MonoObjectRef base)
{
+ MonoClass *klass = (MonoClass*)_klass;
+ MonoClassField *field;
+ MonoType *fieldType;
+ MonoClass * fieldKlass;
+
if (_klass == NULL)
return;
-
- MonoClass *klass = (MonoClass*)_klass;
- MonoClassField *field = mono_class_get_field_from_name(klass,name);
-
+ field = mono_class_get_field_from_name(klass,name);
if (field == NULL)
return;
- MonoType *fieldType = field->type;
- MonoClass * fieldKlass = mono_class_from_mono_type(fieldType);
+ fieldType = mono_field_get_type(field);
+ fieldKlass = mono_class_from_mono_type(fieldType);
mono_field_set_value_object(klass,field, (MonoObject*) base,
(MonoObject*) ObjC2Mono(value, (MonoClassRef) fieldKlass, FALSE));
}
@@ -664,13 +897,14 @@
NSObjectRef MonoGetPropertyValue(MonoClassRef _klass, const char * name,
MonoObjectRef base)
{
+ MonoClass *klass = (MonoClass*)_klass;
+ MonoProperty *prop;
+ MonoObject *res, *ex;
if (_klass == NULL)
return NULL;
- MonoClass *klass = (MonoClass*)_klass;
- MonoProperty *prop = mono_class_get_property_from_name(klass,name);
- MonoObject *res, *ex = NULL;
-
+ prop = mono_class_get_property_from_name(klass,name);
+ ex = NULL;
res = mono_property_get_value(prop, (MonoObject*) base, NULL, &ex);
if (ex != NULL)
{
@@ -682,58 +916,68 @@
void MonoSetPropertyValue(MonoClassRef _klass, const char * name, NSObjectRef
value, MonoObjectRef base)
{
+ MonoClass *klass = (MonoClass*)_klass;
+ MonoObject *ex;
+ MonoProperty *prop;
+ MonoType *argType;
+ MonoClass *argKlass;
+ BOOL byVal;
+
if (_klass == NULL)
return;
- MonoClass *klass = (MonoClass*)_klass;
- MonoObject *ex = NULL;
- MonoProperty *prop = mono_class_get_property_from_name(klass,name);
- MonoType *argType = prop->set->signature->params[0];
- MonoClass *argKlass = mono_class_from_mono_type(argType);
- BOOL byVal = MonoTypeIsValueType(argType);
- gpointer* args = { (gpointer)ObjC2Mono(value, (MonoClassRef) argKlass,
byVal ) };
+ ex = NULL;
+ prop = mono_class_get_property_from_name(klass,name);
+ argType =
_mono_method_get_signature(mono_property_get_set_method(prop))->params[0];
+ argKlass = mono_class_from_mono_type(argType);
+ byVal = MonoTypeIsValueType(argType);
+ {
+ gpointer* args = { (gpointer)ObjC2Mono(value, (MonoClassRef)
argKlass, byVal ) };
- mono_property_set_value(prop, (MonoObject*) base, args, &ex);
-
- if (byVal && args[0] != NULL)
- free(args[0]);
-
- if (ex != NULL)
- mono_print_unhandled_exception(ex);
+ mono_property_set_value(prop, (MonoObject*) base, args, &ex);
+
+ if (byVal && args[0] != NULL)
+ free(args[0]);
+
+ if (ex != NULL)
+ mono_print_unhandled_exception(ex);
+ }
}
NSObjectRef MonoInvoke(MonoClassRef _klass, const char * methodName,
MonoObjectRef base, NSArrayRef args)
{
+ MonoClass *klass = (MonoClass*)_klass;
+ unsigned count;
+ MonoMethod * method;
+
if (_klass == NULL)
return NULL;
- MonoClass *klass = (MonoClass*)_klass;
// this is a simplication that does not deal with paramarray, out, and
ref parameters
- unsigned count = NSArrayGetLength(args);
- MonoMethod * method = mono_find_method_by_name(klass,methodName,count);
+ count = NSArrayGetLength(args);
+ method = mono_find_method_by_name(klass,methodName,count);
if (method != NULL)
{
gpointer *monoArgs= (gpointer*)malloc(count * sizeof(gpointer));
int i;
+ MonoObject *res = NULL;
+ MonoObject *ex = NULL;
for (i = 0; i < count; ++i)
{
NSObjectRef arg = NSArrayGetItem(args,i);
- MonoType *type = method->signature->params[i];
+ MonoType *type =
_mono_method_get_signature(method)->params[i];
MonoClass *klass = mono_class_from_mono_type(type);
monoArgs[i] = (gpointer)ObjC2Mono(arg,
(MonoClassRef)klass, MonoTypeIsValueType(type));
}
- MonoObject *res = NULL;
- MonoObject *ex = NULL;
-
res = mono_runtime_invoke(method, (MonoObject*)base, monoArgs,
&ex);
for (i = 0; i < count; ++i)
{
- MonoType *type = method->signature->params[i];
+ MonoType *type =
_mono_method_get_signature(method)->params[i];
if (MonoTypeIsValueType(type) && monoArgs[i] != NULL)
free(monoArgs[i]);
@@ -758,39 +1002,37 @@
if (obj == NULL)
return ToNSString("nil");
- return MonoClassGetName((MonoClassRef)mono_object_class(obj));
+ return MonoClassGetName((MonoClassRef)mono_object_get_class(obj));
}
NSObjectRef MonoClassGetName(MonoClassRef _klass)
{
+ MonoClass *klass = (MonoClass*)_klass;
+
if (_klass == NULL)
return ToNSString("nil");
-
- MonoClass *klass = (MonoClass*)_klass;
-
- if (klass->name_space == NULL
- || strlen(klass->name_space) == 0)
- return ToNSString(klass->name);
- return FormatToNSString("%s.%s",klass->name_space,klass->name);
+ if (mono_class_get_namespace(klass) == NULL
+ || strlen(mono_class_get_namespace(klass)) == 0)
+ return ToNSString(mono_class_get_name(klass));
+ return
FormatToNSString("%s.%s",mono_class_get_namespace(klass),mono_class_get_name(klass));
}
NSObjectRef MonoClassGetAssemblyName(MonoClassRef _klass)
{
+ MonoClass *klass = (MonoClass*)_klass;
+
if (_klass == NULL)
return ToNSString("nil");
-
- MonoClass *klass = (MonoClass*)_klass;
- return ToNSString(klass->image->assembly_name);
+ return ToNSString(mono_class_get_image(klass)->assembly_name);
}
MonoClassRef MonoClassGetElementClass(MonoClassRef _klass)
{
+ MonoClass *klass = (MonoClass*)_klass;
+
if (_klass == NULL)
return NULL;
-
- MonoClass *klass = (MonoClass*)_klass;
-
- return (MonoClassRef)klass->element_class;
+ return (MonoClassRef)mono_class_get_element_class(klass);
}
MonoObjectRef MonoStringNew(const char * str)
@@ -846,20 +1088,20 @@
// MonoMethodInfo
MonoClassRef MonoMethodGetOwnerKlass(MonoObjectRef _methodInfo)
{
- MonoReflectionMethod *methodInfo = (MonoReflectionMethod *)_methodInfo;
- return (MonoClassRef)methodInfo->method->klass;
+ _MonoReflectionMethod *methodInfo = (_MonoReflectionMethod
*)_methodInfo;
+ return (MonoClassRef)mono_method_get_class(methodInfo->method);
}
const char * MonoMethodGetName(MonoObjectRef _methodInfo)
{
- MonoReflectionMethod *methodInfo = (MonoReflectionMethod *)_methodInfo;
- return methodInfo->method->name;
+ _MonoReflectionMethod *methodInfo = (_MonoReflectionMethod
*)_methodInfo;
+ return mono_method_get_name(methodInfo->method);
}
MonoClassRef MonoMethodGetReturnKlass(MonoObjectRef _methodInfo)
{
- MonoReflectionMethod *methodInfo = (MonoReflectionMethod *)_methodInfo;
- return
(MonoClassRef)mono_class_from_mono_type(methodInfo->method->signature->ret);
+ _MonoReflectionMethod *methodInfo = (_MonoReflectionMethod
*)_methodInfo;
+ return
(MonoClassRef)mono_class_from_mono_type(_mono_method_get_signature(methodInfo->method)->ret);
}
NSArrayRef/*MonoParameterInfo[]*/ MonoMethodGetParameters(MonoObjectRef
_methodInfo)
@@ -878,6 +1120,16 @@
}
+typedef struct {
+ MonoObject object;
+ MonoReflectionType *ClassImpl;
+ MonoObject *DefaultValueImpl;
+ MonoObject *MemberImpl;
+ MonoString *NameImpl;
+ gint32 PositionImpl;
+ guint32 AttrsImpl;
+ MonoObject *MarshalAsImpl;
+} MonoReflectionParameter;
// MonoParameterInfo
MonoClassRef MonoParameterGetOwnerKlass(MonoObjectRef _parameterInfo)
{
@@ -917,6 +1169,11 @@
// MonoPropertyInfo
+struct _MonoReflectionProperty {
+ MonoObject object;
+ MonoClass *klass;
+ MonoProperty *property;
+};
MonoClassRef MonoPropertyGetOwnerKlass(MonoObjectRef _propertyInfo)
{
MonoReflectionProperty* propertyInfo =
(MonoReflectionProperty*)_propertyInfo;
@@ -926,13 +1183,13 @@
MonoClassRef MonoPropertyGetKlass(MonoObjectRef _propertyInfo)
{
MonoReflectionProperty* propertyInfo =
(MonoReflectionProperty*)_propertyInfo;
- return
(MonoClassRef)mono_class_from_mono_type(propertyInfo->property->get->signature->ret);
+ return
(MonoClassRef)mono_class_from_mono_type(_mono_method_get_signature(mono_property_get_get_method(propertyInfo->property))->ret);
}
const char * MonoPropertyGetName(MonoObjectRef _propertyInfo)
{
MonoReflectionProperty* propertyInfo =
(MonoReflectionProperty*)_propertyInfo;
- return propertyInfo->property->name;
+ return mono_property_get_name(propertyInfo->property);
}
NSObjectRef MonoPropertyGetValue(MonoObjectRef _propertyInfo, MonoObjectRef
base)
@@ -948,6 +1205,14 @@
// MonoFieldInfo
+struct _MonoReflectionField {
+ MonoObject object;
+ MonoClass *klass;
+ MonoClassField *field;
+ MonoString *name;
+ MonoReflectionType *type;
+ guint32 attrs;
+};
MonoClassRef MonoFieldGetOwnerKlass(MonoObjectRef _fieldInfo)
{
MonoReflectionField* fieldInfo = (MonoReflectionField*)_fieldInfo;
@@ -957,13 +1222,13 @@
MonoClassRef MonoFieldGetKlass(MonoObjectRef _fieldInfo)
{
MonoReflectionField* fieldInfo = (MonoReflectionField*)_fieldInfo;
- return (MonoClassRef)mono_class_from_mono_type(fieldInfo->field->type);
+ return
(MonoClassRef)mono_class_from_mono_type(mono_field_get_type(fieldInfo->field));
}
const char * MonoFieldGetName(MonoObjectRef _fieldInfo)
{
MonoReflectionField* fieldInfo = (MonoReflectionField*)_fieldInfo;
- return fieldInfo->field->name;
+ return mono_field_get_name(fieldInfo->field);
}
NSObjectRef MonoFieldGetValue(MonoObjectRef _fieldInfo, MonoObjectRef base)
_______________________________________________
Mono-patches maillist - [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches
