*
* Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
- * Copyright 2011 Xamarin Inc (http://www.xamarin.com).
+ * Copyright 2011-2012 Xamarin Inc (http://www.xamarin.com).
*/
#include <config.h>
#include <mono/metadata/mono-debug.h>
#include <mono/metadata/mono-ptr-array.h>
#include <mono/metadata/verify-internals.h>
+#include <mono/metadata/runtime.h>
#include <mono/io-layer/io-layer.h>
#include <mono/utils/strtod.h>
#include <mono/utils/monobitset.h>
#include <mono/utils/mono-error-internals.h>
#include <mono/utils/mono-mmap.h>
#include <mono/utils/mono-io-portability.h>
+#include <mono/utils/mono-digest.h>
#if defined (HOST_WIN32)
#include <windows.h>
extern MonoString* ves_icall_System_Environment_GetOSVersionString (void) MONO_INTERNAL;
-static MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void);
+ICALL_EXPORT MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void);
static MonoArray*
type_array_from_modifiers (MonoImage *image, MonoType *type, int optional);
/*
* We expect a pointer to a char, not a string
*/
-static gboolean
+ICALL_EXPORT gboolean
mono_double_ParseImpl (char *ptr, double *result)
{
gchar *endptr = NULL;
return TRUE;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Array_GetValueImpl (MonoObject *this, guint32 pos)
{
MonoClass *ac;
return *ea;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Array_GetValue (MonoObject *this, MonoObject *idxs)
{
MonoClass *ac, *ic;
return ves_icall_System_Array_GetValueImpl (this, pos);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32 pos)
{
MonoClass *ac, *vc, *ec;
#undef ASSIGN_REAL
}
-static void
+ICALL_EXPORT void
ves_icall_System_Array_SetValue (MonoArray *this, MonoObject *value,
MonoArray *idxs)
{
ves_icall_System_Array_SetValueImpl (this, value, pos);
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
ves_icall_System_Array_CreateInstanceImpl (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
{
MonoClass *aklass, *klass;
return array;
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
ves_icall_System_Array_CreateInstanceImpl64 (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
{
MonoClass *aklass, *klass;
return array;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_Array_GetRank (MonoObject *this)
{
MONO_ARCH_SAVE_REGS;
return this->vtable->klass->rank;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_Array_GetLength (MonoArray *this, gint32 dimension)
{
gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
return length;
}
-static gint64
+ICALL_EXPORT gint64
ves_icall_System_Array_GetLongLength (MonoArray *this, gint32 dimension)
{
gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
return this->bounds [dimension].length;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_Array_GetLowerBound (MonoArray *this, gint32 dimension)
{
gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
return this->bounds [dimension].lower_bound;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Array_ClearInternal (MonoArray *arr, int idx, int length)
{
int sz = mono_array_element_size (mono_object_class (arr));
mono_gc_bzero (mono_array_addr_with_size (arr, sz, idx), length * sz);
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_System_Array_FastCopy (MonoArray *source, int source_idx, MonoArray* dest, int dest_idx, int length)
{
int element_size;
return TRUE;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Array_GetGenericValueImpl (MonoObject *this, guint32 pos, gpointer value)
{
MonoClass *ac;
mono_gc_memmove (value, ea, esize);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Array_SetGenericValueImpl (MonoObject *this, guint32 pos, gpointer value)
{
MonoClass *ac, *ec;
}
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArray *array, MonoClassField *field_handle)
{
MonoClass *klass = array->obj.vtable->klass;
#endif
}
-static gint
+ICALL_EXPORT gint
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData (void)
{
MONO_ARCH_SAVE_REGS;
return offsetof (MonoString, chars);
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (MonoObject *obj)
{
MONO_ARCH_SAVE_REGS;
return mono_object_clone (obj);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (MonoType *handle)
{
MonoClass *klass;
mono_runtime_class_init (vtable);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (MonoImage *image)
{
MONO_ARCH_SAVE_REGS;
}
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack (void)
{
guint8 *stack_addr;
return TRUE;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Object_MemberwiseClone (MonoObject *this)
{
MONO_ARCH_SAVE_REGS;
return mono_object_clone (this);
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this, MonoArray **fields)
{
MonoClass *klass;
return result;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_ValueType_Equals (MonoObject *this, MonoObject *that, MonoArray **fields)
{
MonoClass *klass;
}
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_System_Object_GetType (MonoObject *obj)
{
MONO_ARCH_SAVE_REGS;
- if (obj->vtable->klass != mono_defaults.transparent_proxy_class)
- return mono_type_get_object (mono_object_domain (obj), &obj->vtable->klass->byval_arg);
- else
+#ifndef DISABLE_REMOTING
+ if (obj->vtable->klass == mono_defaults.transparent_proxy_class)
return mono_type_get_object (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg);
+ else
+#endif
+ return mono_type_get_object (mono_object_domain (obj), &obj->vtable->klass->byval_arg);
}
-static void
+ICALL_EXPORT void
mono_type_type_from_obj (MonoReflectionType *mtype, MonoObject *obj)
{
MONO_ARCH_SAVE_REGS;
g_assert (mtype->type->type);
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, gboolean create_open_instance)
{
MONO_ARCH_SAVE_REGS;
return mono_image_create_token (mb->dynamic_image, obj, create_open_instance, TRUE);
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder *mb,
MonoReflectionMethod *method,
MonoArray *opt_param_types)
mb->dynamic_image, (MonoObject *) method, opt_param_types);
}
-static void
+ICALL_EXPORT void
ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, HANDLE file)
{
MONO_ARCH_SAVE_REGS;
mono_image_create_pefile (mb, file);
}
-static void
+ICALL_EXPORT void
ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb)
{
MONO_ARCH_SAVE_REGS;
mono_image_build_metadata (mb);
}
-static void
+ICALL_EXPORT void
ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, guint32 token)
{
MONO_ARCH_SAVE_REGS;
}
#endif
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_type_from_name (MonoString *name,
MonoBoolean throwOnError,
MonoBoolean ignoreCase)
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_type_from_handle (MonoType *handle)
{
MonoDomain *domain = mono_domain_get ();
return mono_type_get_object (domain, handle);
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Type_EqualsInternal (MonoReflectionType *type, MonoReflectionType *c)
{
MONO_ARCH_SAVE_REGS;
TYPECODE_STRING = 18
} TypeCode;
-static guint32
+ICALL_EXPORT guint32
ves_icall_type_GetTypeCodeInternal (MonoReflectionType *type)
{
int t = type->type->type;
return 0;
}
-static guint32
+ICALL_EXPORT guint32
ves_icall_type_is_subtype_of (MonoReflectionType *type, MonoReflectionType *c, MonoBoolean check_interfaces)
{
MonoDomain *domain;
return type;
}
-static guint32
+ICALL_EXPORT guint32
ves_icall_type_is_assignable_from (MonoReflectionType *type, MonoReflectionType *c)
{
MonoDomain *domain;
return mono_class_is_assignable_from (klass, klassc);
}
-static guint32
+ICALL_EXPORT guint32
ves_icall_type_IsInstanceOfType (MonoReflectionType *type, MonoObject *obj)
{
MonoClass *klass = mono_class_from_mono_type (type->type);
return mono_object_isinst (obj, klass) != NULL;
}
-static guint32
+ICALL_EXPORT guint32
ves_icall_get_attributes (MonoReflectionType *type)
{
MonoClass *klass = mono_class_from_mono_type (type->type);
return klass->flags;
}
-static MonoReflectionMarshal*
-ves_icall_System_Reflection_FieldInfo_GetUnmanagedMarshal (MonoReflectionField *field)
+ICALL_EXPORT MonoReflectionMarshalAsAttribute*
+ves_icall_System_Reflection_FieldInfo_get_marshal_info (MonoReflectionField *field)
{
MonoClass *klass = field->field->parent;
MonoMarshalType *info;
if (!info->fields [i].mspec)
return NULL;
else
- return mono_reflection_marshal_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec);
+ return mono_reflection_marshal_as_attribute_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec);
}
}
return NULL;
}
-static MonoReflectionField*
+ICALL_EXPORT MonoReflectionField*
ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (MonoClassField *handle, MonoType *type)
{
gboolean found = FALSE;
return mono_field_get_object (mono_domain_get (), klass, handle);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionField *field, MonoBoolean optional)
{
MonoError error;
return type_array_from_modifiers (field->field->parent->image, type, optional);
}
-static int
+ICALL_EXPORT int
vell_icall_get_method_attributes (MonoMethod *method)
{
return method->flags;
}
-static void
+ICALL_EXPORT void
ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
{
MonoError error;
info->callconv |= (sig->hasthis << 5) | (sig->explicit_this << 6);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_get_parameter_info (MonoMethod *method, MonoReflectionMethod *member)
{
MonoDomain *domain = mono_domain_get ();
return mono_param_get_objects_internal (domain, method, member->reftype ? mono_class_from_mono_type (member->reftype->type) : NULL);
}
-static MonoReflectionMarshal*
+ICALL_EXPORT MonoReflectionMarshalAsAttribute*
ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method)
{
MonoDomain *domain = mono_domain_get ();
- MonoReflectionMarshal* res = NULL;
+ MonoReflectionMarshalAsAttribute* res = NULL;
MonoMarshalSpec **mspecs;
int i;
mono_method_get_marshal_info (method, mspecs);
if (mspecs [0])
- res = mono_reflection_marshal_from_marshal_spec (domain, method->klass, mspecs [0]);
+ res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [0]);
for (i = mono_method_signature (method)->param_count; i >= 0; i--)
if (mspecs [i])
return res;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_MonoField_GetFieldOffset (MonoReflectionField *field)
{
MonoClass *parent = field->field->parent;
return field->field->offset - sizeof (MonoObject);
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean declaring)
{
MonoClass *parent;
return mono_type_get_object (mono_object_domain (field), &parent->byval_arg);
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_MonoField_GetValueInternal (MonoReflectionField *field, MonoObject *obj)
{
MonoClass *fklass = field->klass;
return mono_field_get_value_object (domain, cf, obj);
}
-static void
+ICALL_EXPORT void
ves_icall_MonoField_SetValueInternal (MonoReflectionField *field, MonoObject *obj, MonoObject *value)
{
MonoError error;
}
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_MonoField_GetRawConstantValue (MonoReflectionField *this)
{
MonoObject *o = NULL;
return o;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_MonoField_ResolveType (MonoReflectionField *ref_field)
{
MonoError error;
return mono_type_get_object (mono_object_domain (ref_field), type);
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_MonoGenericMethod_get_ReflectedType (MonoReflectionGenericMethod *rmethod)
{
MonoMethod *method = rmethod->method.method;
PInfo_Name = 1 << 5
} PInfo;
-static void
+ICALL_EXPORT void
ves_icall_get_property_info (MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info)
{
MonoDomain *domain = mono_object_domain (property);
*/
}
-static void
+ICALL_EXPORT void
ves_icall_get_event_info (MonoReflectionMonoEvent *event, MonoEventInfo *info)
{
MonoDomain *domain = mono_object_domain (event);
mono_metadata_free_type (inflated);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetInterfaces (MonoReflectionType* type)
{
MonoError error;
return NULL;
}
-static void
+ICALL_EXPORT void
ves_icall_Type_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType *iface, MonoArray **targets, MonoArray **methods)
{
gboolean variance_used;
}
}
-static void
+ICALL_EXPORT void
ves_icall_Type_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *size)
{
MonoClass *klass = mono_class_from_mono_type (type->type);
}
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_MonoType_GetElementType (MonoReflectionType *type)
{
MonoClass *class;
return NULL;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_get_type_parent (MonoReflectionType *type)
{
MonoClass *class = mono_class_from_mono_type (type->type);
return class->parent ? mono_type_get_object (mono_object_domain (type), &class->parent->byval_arg): NULL;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_type_ispointer (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return type->type->type == MONO_TYPE_PTR;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_type_isprimitive (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return (!type->type->byref && (((type->type->type >= MONO_TYPE_BOOLEAN) && (type->type->type <= MONO_TYPE_R8)) || (type->type->type == MONO_TYPE_I) || (type->type->type == MONO_TYPE_U)));
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_type_isbyref (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return type->type->byref;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_type_iscomobject (MonoReflectionType *type)
{
MonoClass *klass = mono_class_from_mono_type (type->type);
return (klass && klass->is_com_object);
}
-static MonoReflectionModule*
+ICALL_EXPORT MonoReflectionModule*
ves_icall_MonoType_get_Module (MonoReflectionType *type)
{
MonoClass *class = mono_class_from_mono_type (type->type);
return mono_module_get_object (mono_object_domain (type), class->image);
}
-static MonoReflectionAssembly*
+ICALL_EXPORT MonoReflectionAssembly*
ves_icall_MonoType_get_Assembly (MonoReflectionType *type)
{
MonoDomain *domain = mono_domain_get ();
return mono_assembly_get_object (domain, class->image->assembly);
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
{
MonoDomain *domain = mono_domain_get ();
return class ? mono_type_get_object (domain, &class->byval_arg) : NULL;
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_MonoType_get_Name (MonoReflectionType *type)
{
MonoDomain *domain = mono_domain_get ();
}
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_MonoType_get_Namespace (MonoReflectionType *type)
{
MonoDomain *domain = mono_domain_get ();
return mono_string_new (domain, class->name_space);
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_MonoType_GetArrayRank (MonoReflectionType *type)
{
MonoClass *class;
return class->rank;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type)
{
MonoArray *res;
return res;
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_Type_get_IsGenericTypeDefinition (MonoReflectionType *type)
{
MonoClass *klass;
return klass->generic_container != NULL;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type)
{
MonoClass *klass;
return NULL;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
{
MonoClass *class;
return mono_type_get_object (mono_object_domain (type), geninst);
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_Type_get_IsGenericInstance (MonoReflectionType *type)
{
MonoClass *klass;
return klass->generic_class != NULL;
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_Type_get_IsGenericType (MonoReflectionType *type)
{
MonoClass *klass;
return klass->generic_class != NULL || klass->generic_container != NULL;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return -1;
}
-static GenericParameterAttributes
+ICALL_EXPORT GenericParameterAttributes
ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return mono_generic_param_info (type->type->data.generic_param)->flags;
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type)
{
MonoGenericParamInfo *param_info;
return res;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_MonoType_get_IsGenericParameter (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return is_generic_parameter (type->type);
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_TypeBuilder_get_IsGenericParameter (MonoReflectionTypeBuilder *tb)
{
MONO_ARCH_SAVE_REGS;
return is_generic_parameter (tb->type.type);
}
-static void
+ICALL_EXPORT void
ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType *enumtype,
MonoReflectionType *t)
{
enumtype->type = t->type;
}
-static MonoReflectionMethod*
+ICALL_EXPORT MonoReflectionMethod*
ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type,
MonoReflectionMethod* generic)
{
-static MonoReflectionMethod *
+ICALL_EXPORT MonoReflectionMethod *
ves_icall_MonoType_get_DeclaringMethod (MonoReflectionType *ref_type)
{
MonoMethod *method;
return mono_method_get_object (mono_object_domain (ref_type), method, method->klass);
}
-static MonoReflectionDllImportAttribute*
+ICALL_EXPORT MonoReflectionDllImportAttribute*
ves_icall_MonoMethod_GetDllImportAttribute (MonoMethod *method)
{
static MonoClass *DllImportAttributeClass = NULL;
return attr;
}
-static MonoReflectionMethod *
+ICALL_EXPORT MonoReflectionMethod *
ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method)
{
MonoMethodInflated *imethod;
return mono_method_get_object (mono_object_domain (method), result, NULL);
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_MonoMethod_get_IsGenericMethod (MonoReflectionMethod *method)
{
MONO_ARCH_SAVE_REGS;
return mono_method_signature (method->method)->generic_param_count != 0;
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method)
{
MONO_ARCH_SAVE_REGS;
return method->method->is_generic;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method)
{
MonoArray *res;
return res;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoArray *params, MonoException **exc)
{
/*
return mono_runtime_invoke_array (m, obj, params, NULL);
}
-static MonoObject *
+#ifndef DISABLE_REMOTING
+ICALL_EXPORT MonoObject *
ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoArray *params, MonoArray **outArgs)
{
MonoDomain *domain = mono_object_domain (method);
return result;
}
+#endif
static guint64
read_enum_value (char *mem, int type)
return;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Enum_ToObject (MonoReflectionType *enumType, MonoObject *value)
{
MonoDomain *domain;
return res;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Enum_get_value (MonoObject *this)
{
MonoObject *res;
return res;
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_System_Enum_get_underlying_type (MonoReflectionType *type)
{
MonoType *etype;
return mono_type_get_object (mono_object_domain (type), etype);
}
-static int
+ICALL_EXPORT int
ves_icall_System_Enum_compare_value_to (MonoObject *this, MonoObject *other)
{
gpointer tdata = (char *)this + sizeof (MonoObject);
return 0;
}
-static int
+ICALL_EXPORT int
ves_icall_System_Enum_get_hashcode (MonoObject *this)
{
gpointer data = (char *)this + sizeof (MonoObject);
return 0;
}
-static void
+ICALL_EXPORT void
ves_icall_get_enum_info (MonoReflectionType *type, MonoEnumInfo *info)
{
MonoDomain *domain = mono_object_domain (type);
BFLAGS_OptionalParamBinding = 0x40000
};
-static MonoReflectionField *
+ICALL_EXPORT MonoReflectionField *
ves_icall_Type_GetField (MonoReflectionType *type, MonoString *name, guint32 bflags)
{
MonoDomain *domain;
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetFields_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
{
MonoDomain *domain;
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
{
static MonoClass *MethodInfo_array;
return res;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
{
MonoDomain *domain;
return method_nonpublic (accessor, start_klass);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
{
MonoException *ex;
return NULL;
}
-static MonoReflectionEvent *
+ICALL_EXPORT MonoReflectionEvent *
ves_icall_MonoType_GetEvent (MonoReflectionType *type, MonoString *name, guint32 bflags)
{
MonoDomain *domain;
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetEvents_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
{
MonoException *ex;
return NULL;
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_Type_GetNestedType (MonoReflectionType *type, MonoString *name, guint32 bflags)
{
MonoDomain *domain;
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetNestedTypes (MonoReflectionType *type, guint32 bflags)
{
MonoDomain *domain;
return res;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *assembly, MonoReflectionModule *module, MonoString *name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
gchar *str;
return FALSE;
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssembly *assembly, MonoBoolean escaped)
{
MonoDomain *domain = mono_object_domain (assembly);
return res;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Reflection_Assembly_get_global_assembly_cache (MonoReflectionAssembly *assembly)
{
MonoAssembly *mass = assembly->assembly;
return mass->in_gac;
}
-static MonoReflectionAssembly*
+ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString *mname, MonoObject *evidence)
{
gchar *name;
return mono_assembly_get_object (mono_domain_get (), res);
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Reflection_Assembly_get_location (MonoReflectionAssembly *assembly)
{
MonoDomain *domain = mono_object_domain (assembly);
return res;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Reflection_Assembly_get_ReflectionOnly (MonoReflectionAssembly *assembly)
{
MONO_ARCH_SAVE_REGS;
return assembly->assembly->ref_only;
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (MonoReflectionAssembly *assembly)
{
MonoDomain *domain = mono_object_domain (assembly);
return mono_string_new (domain, assembly->assembly->image->version);
}
-static MonoReflectionMethod*
+ICALL_EXPORT MonoReflectionMethod*
ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssembly *assembly)
{
guint32 token = mono_image_get_entry_point (assembly->assembly->image);
return mono_method_get_object (mono_object_domain (assembly), mono_get_method (assembly->assembly->image, token, NULL), NULL);
}
-static MonoReflectionModule*
+ICALL_EXPORT MonoReflectionModule*
ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAssembly *assembly)
{
return mono_module_get_object (mono_object_domain (assembly), assembly->assembly->image);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly *assembly)
{
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
return result;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly *assembly)
{
static MonoClass *System_Reflection_AssemblyName;
return result;
}
-typedef struct {
- MonoArray *res;
- int idx;
-} NameSpaceInfo;
-
-static void
-foreach_namespace (const char* key, gconstpointer val, NameSpaceInfo *info)
-{
- MonoString *name = mono_string_new (mono_object_domain (info->res), key);
-
- mono_array_setref (info->res, info->idx, name);
- info->idx++;
-}
-
-static MonoArray*
-ves_icall_System_Reflection_Assembly_GetNamespaces (MonoReflectionAssembly *assembly)
-{
- MonoImage *img = assembly->assembly->image;
- MonoArray *res;
- NameSpaceInfo info;
- int len;
-
- MONO_ARCH_SAVE_REGS;
-
- mono_image_lock (img);
- mono_image_init_name_cache (img);
-
-RETRY_LEN:
- len = g_hash_table_size (img->name_cache);
- mono_image_unlock (img);
-
- /*we can't create objects holding the image lock */
- res = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, len);
-
- mono_image_lock (img);
- /*len might have changed, create a new array*/
- if (len != g_hash_table_size (img->name_cache))
- goto RETRY_LEN;
-
- info.res = res;
- info.idx = 0;
- g_hash_table_foreach (img->name_cache, (GHFunc)foreach_namespace, &info);
- mono_image_unlock (img);
-
- return res;
-}
-
/* move this in some file in mono/util/ */
static char *
g_concat_dir_and_file (const char *dir, const char *file)
return g_strconcat (dir, file, NULL);
}
-static void *
+ICALL_EXPORT void *
ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly *assembly, MonoString *name, gint32 *size, MonoReflectionModule **ref_module)
{
char *n = mono_string_to_utf8 (name);
return (void*)mono_image_get_resource (module, cols [MONO_MANIFEST_OFFSET], (guint32*)size);
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoManifestResourceInfo *info)
{
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
return TRUE;
}
-static MonoObject*
+ICALL_EXPORT MonoObject*
ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoBoolean resource_modules)
{
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
return (MonoObject*)result;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly *assembly)
{
MonoDomain *domain = mono_domain_get();
return res;
}
-static MonoReflectionMethod*
+ICALL_EXPORT MonoReflectionMethod*
ves_icall_GetCurrentMethod (void)
{
MonoMethod *m = mono_method_get_last_managed ();
return klass->methods [offset];
}
-static MonoReflectionMethod*
+ICALL_EXPORT MonoReflectionMethod*
ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (MonoMethod *method, MonoType *type)
{
MonoClass *klass;
return mono_method_get_object (mono_domain_get (), method, klass);
}
-static MonoReflectionMethod*
+ICALL_EXPORT MonoReflectionMethod*
ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (MonoMethod *method)
{
return mono_method_get_object (mono_domain_get (), method, NULL);
}
-static MonoReflectionMethodBody*
+ICALL_EXPORT MonoReflectionMethodBody*
ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod *method)
{
return mono_method_body_get_object (mono_domain_get (), method);
}
-static MonoReflectionAssembly*
+ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetExecutingAssembly (void)
{
MonoMethod *dest = NULL;
}
-static MonoReflectionAssembly*
+ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetEntryAssembly (void)
{
MonoDomain* domain = mono_domain_get ();
return mono_assembly_get_object (domain, domain->entry_assembly);
}
-static MonoReflectionAssembly*
+ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetCallingAssembly (void)
{
MonoMethod *m;
return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly);
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_MonoType_getFullName (MonoReflectionType *object, gboolean full_name,
gboolean assembly_qualified)
{
return res;
}
-static int
+ICALL_EXPORT int
vell_icall_MonoType_get_core_clr_security_level (MonoReflectionType *this)
{
MonoClass *klass = mono_class_from_mono_type (this->type);
}
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Reflection_Assembly_get_fullName (MonoReflectionAssembly *assembly)
{
MonoDomain *domain = mono_object_domain (assembly);
return res;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Reflection_Assembly_FillName (MonoReflectionAssembly *assembly, MonoReflectionAssemblyName *aname)
{
gchar *absolute;
g_free (absolute);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, MonoReflectionAssemblyName *aname)
{
char *filename;
mono_image_close (image);
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Reflection_Assembly_LoadPermissions (MonoReflectionAssembly *assembly,
char **minimum, guint32 *minLength, char **optional, guint32 *optLength, char **refused, guint32 *refLength)
{
return res;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoBoolean exportedOnly)
{
MonoArray *res = NULL;
return res;
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_System_Reflection_AssemblyName_ParseName (MonoReflectionAssemblyName *name, MonoString *assname)
{
MonoAssemblyName aname;
return TRUE;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule *module)
{
MonoDomain *domain = mono_object_domain (module);
return mono_type_get_object (domain, &klass->byval_arg);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Reflection_Module_Close (MonoReflectionModule *module)
{
/*if (module->image)
mono_image_close (module->image);*/
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_Reflection_Module_GetGuidInternal (MonoReflectionModule *module)
{
MonoDomain *domain = mono_object_domain (module);
return mono_string_new (domain, module->image->guid);
}
-static gpointer
+ICALL_EXPORT gpointer
ves_icall_System_Reflection_Module_GetHINSTANCE (MonoReflectionModule *module)
{
#ifdef HOST_WIN32
return (gpointer) (-1);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Reflection_Module_GetPEKind (MonoImage *image, gint32 *pe_kind, gint32 *machine)
{
if (image->dynamic) {
}
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_Reflection_Module_GetMDStreamVersion (MonoImage *image)
{
return (image->md_version_major << 16) | (image->md_version_minor);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *module)
{
MonoArray *exceptions;
context->method_inst = NULL;
}
-static MonoType*
+ICALL_EXPORT MonoType*
ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
MonoClass *klass;
return NULL;
}
-static MonoMethod*
+ICALL_EXPORT MonoMethod*
ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
int table = mono_metadata_token_table (token);
return method;
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_Reflection_Module_ResolveStringToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
{
int index = mono_metadata_token_index (token);
return mono_ldstr (mono_domain_get (), image, index);
}
-static MonoClassField*
+ICALL_EXPORT MonoClassField*
ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
MonoClass *klass;
}
-static MonoObject*
+ICALL_EXPORT MonoObject*
ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
int table = mono_metadata_token_table (token);
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *error)
{
int table = mono_metadata_token_table (token);
return res;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, MonoString *smodifiers)
{
MonoClass *klass;
return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_Type_IsArrayImpl (MonoReflectionType *t)
{
MonoType *type;
mono_raise_exception ((MonoException*)mono_get_exception_type_load (str, NULL));
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_Type_make_array_type (MonoReflectionType *type, int rank)
{
MonoClass *klass, *aklass;
return mono_type_get_object (mono_object_domain (type), &aklass->byval_arg);
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_Type_make_byref_type (MonoReflectionType *type)
{
MonoClass *klass;
return mono_type_get_object (mono_object_domain (type), &klass->this_arg);
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_Type_MakePointerType (MonoReflectionType *type)
{
MonoClass *klass, *pklass;
return mono_type_get_object (mono_object_domain (type), &pklass->byval_arg);
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, MonoObject *target,
MonoReflectionMethod *info, MonoBoolean throwOnBindFailure)
{
return delegate;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Delegate_SetMulticastInvoke (MonoDelegate *this)
{
/* Reset the invoke impl to the default one */
*
* Returns true on success and zero on failure.
*/
-static guint32
+ICALL_EXPORT guint32
ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, MonoArray **data, MonoArray **names)
{
#ifndef HOST_WIN32
#endif
}
-static gpointer
+ICALL_EXPORT gpointer
ves_icall_System_Object_obj_address (MonoObject *this)
{
MONO_ARCH_SAVE_REGS;
}
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_Buffer_ByteLengthInternal (MonoArray *array)
{
MONO_ARCH_SAVE_REGS;
return mono_array_get_byte_length (array);
}
-static gint8
+ICALL_EXPORT gint8
ves_icall_System_Buffer_GetByteInternal (MonoArray *array, gint32 idx)
{
MONO_ARCH_SAVE_REGS;
return mono_array_get (array, gint8, idx);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Buffer_SetByteInternal (MonoArray *array, gint32 idx, gint8 value)
{
MONO_ARCH_SAVE_REGS;
mono_array_set (array, gint8, idx, value);
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Buffer_BlockCopyInternal (MonoArray *src, gint32 src_offset, MonoArray *dest, gint32 dest_offset, gint32 count)
{
guint8 *src_buf, *dest_buf;
MONO_ARCH_SAVE_REGS;
+ /* This is called directly from the class libraries without going through the managed wrapper */
+ MONO_CHECK_ARG_NULL (src);
+ MONO_CHECK_ARG_NULL (dest);
+
/* watch out for integer overflow */
if ((src_offset > mono_array_get_byte_length (src) - count) || (dest_offset > mono_array_get_byte_length (dest) - count))
return FALSE;
return TRUE;
}
-static MonoObject *
+#ifndef DISABLE_REMOTING
+ICALL_EXPORT MonoObject *
ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this, MonoString *class_name)
{
MonoDomain *domain = mono_object_domain (this);
return res;
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_Remoting_RealProxy_InternalGetProxyType (MonoTransparentProxy *tp)
{
return mono_type_get_object (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg);
}
+#endif
/* System.Environment */
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Environment_get_MachineName (void)
{
#if defined (HOST_WIN32)
#endif
}
-static int
+ICALL_EXPORT int
ves_icall_System_Environment_get_Platform (void)
{
#if defined (TARGET_WIN32)
#endif
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Environment_get_NewLine (void)
{
MONO_ARCH_SAVE_REGS;
#endif
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name)
{
const gchar *value;
#endif
#endif
-static MonoArray *
+ICALL_EXPORT MonoArray *
ves_icall_System_Environment_GetEnvironmentVariableNames (void)
{
#ifdef HOST_WIN32
#define g_unsetenv(a) unsetenv(a)
#endif
-static void
+ICALL_EXPORT void
ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, MonoString *value)
{
MonoError error;
#endif
}
-static void
+ICALL_EXPORT void
ves_icall_System_Environment_Exit (int result)
{
MONO_ARCH_SAVE_REGS;
+#ifndef MONO_CROSS_COMPILE
+ mono_runtime_shutdown ();
+#endif
+
mono_threads_set_shutting_down ();
mono_runtime_set_shutting_down ();
exit (result);
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_Environment_GetGacPath (void)
{
return mono_string_new (mono_domain_get (), mono_assembly_getrootdir ());
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_Environment_GetWindowsFolderPath (int folder)
{
#if defined (HOST_WIN32)
return mono_string_new (mono_domain_get (), "");
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
ves_icall_System_Environment_GetLogicalDrives (void)
{
gunichar2 buf [256], *ptr, *dname;
return result;
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_IO_DriveInfo_GetDriveFormat (MonoString *path)
{
gunichar2 volume_name [MAX_PATH + 1];
return mono_string_from_utf16 (volume_name);
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Environment_InternalGetHome (void)
{
MONO_ARCH_SAVE_REGS;
* 1 at entry, and we can not compute a suitable code page number,
* returns the code page as a string
*/
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_Text_Encoding_InternalCodePage (gint32 *int_code_page)
{
const char *cset;
return NULL;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Environment_get_HasShutdownStarted (void)
{
if (mono_runtime_is_shutting_down ())
return FALSE;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Environment_BroadcastSettingChange (void)
{
#ifdef HOST_WIN32
#endif
}
-static void
+ICALL_EXPORT void
ves_icall_MonoMethodMessage_InitMessage (MonoMethodMessage *this,
MonoReflectionMethod *method,
MonoArray *out_args)
mono_message_init (mono_object_domain (this), this, method, out_args);
}
-static MonoBoolean
+#ifndef DISABLE_REMOTING
+ICALL_EXPORT MonoBoolean
ves_icall_IsTransparentProxy (MonoObject *proxy)
{
MONO_ARCH_SAVE_REGS;
return 0;
}
-static MonoReflectionMethod *
+ICALL_EXPORT MonoReflectionMethod *
ves_icall_Remoting_RemotingServices_GetVirtualMethod (
MonoReflectionType *rtype, MonoReflectionMethod *rmethod)
{
return mono_method_get_object (mono_domain_get (), res, NULL);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (MonoReflectionType *type, MonoBoolean enable)
{
MonoClass *klass;
if (enable) vtable->remote = 1;
else vtable->remote = 0;
}
+#endif
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (MonoReflectionType *type)
{
MonoClass *klass;
}
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_IO_get_temp_path (void)
{
MONO_ARCH_SAVE_REGS;
}
#ifndef PLATFORM_NO_DRIVEINFO
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_IO_DriveInfo_GetDiskFreeSpace (MonoString *path_name, guint64 *free_bytes_avail,
guint64 *total_number_of_bytes, guint64 *total_number_of_free_bytes,
gint32 *error)
return result;
}
-static guint32
+ICALL_EXPORT guint32
ves_icall_System_IO_DriveInfo_GetDriveType (MonoString *root_path_name)
{
MONO_ARCH_SAVE_REGS;
}
#endif
-static gpointer
+ICALL_EXPORT gpointer
ves_icall_RuntimeMethod_GetFunctionPointer (MonoMethod *method)
{
MONO_ARCH_SAVE_REGS;
return mono_compile_method (method);
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (void)
{
MonoString *mcpath;
return mono_string_new (mono_domain_get (), machine_config);
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Web_Util_ICalls_get_machine_install_dir (void)
{
MonoString *ipath;
return ipath;
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_get_resources_ptr (MonoReflectionAssembly *assembly, gpointer *result, gint32 *size)
{
MonoPEResourceDataEntry *entry;
return TRUE;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Diagnostics_Debugger_IsAttached_internal (void)
{
return mono_debug_using_mono_debugger () || mono_is_debugger_attached ();
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Diagnostics_Debugger_IsLogging (void)
{
if (mono_get_runtime_callbacks ()->debug_log_is_enabled)
return FALSE;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Diagnostics_Debugger_Log (int level, MonoString *category, MonoString *message)
{
if (mono_get_runtime_callbacks ()->debug_log)
mono_get_runtime_callbacks ()->debug_log (level, category, message);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Diagnostics_DefaultTraceListener_WriteWindowsDebugString (MonoString *message)
{
#if defined (HOST_WIN32)
}
/* Only used for value types */
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionType *type)
{
MonoClass *klass;
return mono_object_new (domain, klass);
}
-static MonoReflectionMethod *
+ICALL_EXPORT MonoReflectionMethod *
ves_icall_MonoMethod_get_base_method (MonoReflectionMethod *m, gboolean definition)
{
MonoClass *klass, *parent;
return mono_method_get_object (mono_domain_get (), result, NULL);
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_MonoMethod_get_name (MonoReflectionMethod *m)
{
MonoMethod *method = m->method;
return m->name;
}
-static void
+ICALL_EXPORT void
mono_ArgIterator_Setup (MonoArgIterator *iter, char* argsp, char* start)
{
MONO_ARCH_SAVE_REGS;
/* g_print ("sig %p, param_count: %d, sent: %d\n", iter->sig, iter->sig->param_count, iter->sig->sentinelpos); */
}
-static MonoTypedRef
+ICALL_EXPORT MonoTypedRef
mono_ArgIterator_IntGetNextArg (MonoArgIterator *iter)
{
guint32 i, arg_size;
return res;
}
-static MonoTypedRef
+ICALL_EXPORT MonoTypedRef
mono_ArgIterator_IntGetNextArgT (MonoArgIterator *iter, MonoType *type)
{
guint32 i, arg_size;
return res;
}
-static MonoType*
+ICALL_EXPORT MonoType*
mono_ArgIterator_IntGetNextArgType (MonoArgIterator *iter)
{
gint i;
return iter->sig->params [i];
}
-static MonoObject*
+ICALL_EXPORT MonoObject*
mono_TypedReference_ToObject (MonoTypedRef tref)
{
MONO_ARCH_SAVE_REGS;
return mono_value_box (mono_domain_get (), tref.klass, tref.value);
}
-static MonoObject*
+ICALL_EXPORT MonoObject*
mono_TypedReference_ToObjectInternal (MonoType *type, gpointer value, MonoClass *klass)
{
MONO_ARCH_SAVE_REGS;
/* create the wrapper, too? */
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_InteropServices_Marshal_Prelink (MonoReflectionMethod *method)
{
MONO_ARCH_SAVE_REGS;
prelink_method (method->method);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (MonoReflectionType *type)
{
MonoClass *klass = mono_class_from_mono_type (type->type);
}
/* These parameters are "readonly" in corlib/System/NumberFormatter.cs */
-static void
+ICALL_EXPORT void
ves_icall_System_NumberFormatter_GetFormatterTables (guint64 const **mantissas,
gint32 const **exponents,
gunichar2 const **digitLowerTable,
*decHexDigits = Formatter_DecHexDigits;
}
-static void
+ICALL_EXPORT void
get_category_data (int version,
guint8 const **category_data,
guint16 const **category_astral_index)
}
/* These parameters are "readonly" in corlib/System/Char.cs */
-static void
+ICALL_EXPORT void
ves_icall_System_Char_GetDataTablePointers (int category_data_version,
guint8 const **category_data,
guint16 const **category_astral_index,
*to_upper_data_high = ToUpperDataHigh;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_MonoDebugger_GetMethodToken (MonoReflectionMethod *method)
{
return method->method->token;
return res;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
param_info_get_type_modifiers (MonoReflectionParameter *param, MonoBoolean optional)
{
MonoType *type = param->ClassImpl->type;
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
property_info_get_type_modifiers (MonoReflectionProperty *property, MonoBoolean optional)
{
MonoType *type = get_property_type (property->property);
type->data.klass = mono_class_from_mono_type (real_type);
}
-static MonoObject*
+ICALL_EXPORT MonoObject*
property_info_get_default_value (MonoReflectionProperty *property)
{
MonoType blob_type;
return o;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
custom_attrs_defined_internal (MonoObject *obj, MonoReflectionType *attr_type)
{
MonoClass *attr_class = mono_class_from_mono_type (attr_type->type);
return found;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
custom_attrs_get_by_type (MonoObject *obj, MonoReflectionType *attr_type)
{
MonoClass *attr_class = attr_type ? mono_class_from_mono_type (attr_type->type) : NULL;
}
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_Mono_Runtime_GetDisplayName (void)
{
char *info;
return display_name;
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code)
{
MonoString *message;
gint a [4], b [4];
MonoException *exc;
+ int havePadding = 0;
ignored = 0;
last = prev_last = 0, prev2_last = 0;
for (i = 0; i < ilength; i++) {
mono_raise_exception (exc);
} else if (isspace (c)) {
ignored++;
+ } else if (havePadding && c != '=') {
+ exc = mono_exception_from_name_msg (mono_get_corlib (),
+ "System", "FormatException",
+ "Invalid character found.");
+ mono_raise_exception (exc);
} else {
+ if (c == '=') havePadding = 1;
prev2_last = prev_last;
prev_last = last;
last = c;
return result;
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
InternalFromBase64String (MonoString *str, MonoBoolean allowWhitespaceOnly)
{
MONO_ARCH_SAVE_REGS;
mono_string_length (str), allowWhitespaceOnly);
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
InternalFromBase64CharArray (MonoArray *input, gint offset, gint length)
{
MONO_ARCH_SAVE_REGS;
length, FALSE);
}
+#ifndef DISABLE_ICALL_TABLES
+
#define ICALL_TYPE(id,name,first)
#define ICALL(id,name,func) Icall_ ## id,
};
#endif
+#endif /* DISABLE_ICALL_TABLES */
+
static GHashTable *icall_hash = NULL;
static GHashTable *jit_icall_hash_name = NULL;
static GHashTable *jit_icall_hash_addr = NULL;
void
mono_icall_init (void)
{
+#ifndef DISABLE_ICALL_TABLES
int i = 0;
/* check that tables are sorted: disable in release */
}
}
}
+#endif
icall_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
}
mono_loader_unlock ();
}
+#ifndef DISABLE_ICALL_TABLES
+
#ifdef HAVE_ARRAY_ELEM_INIT
static int
compare_method_imap (const void *key, const void *elem)
return &icall_type_descs [nameslot - &icall_type_names_idx [0]];
}
-#else
+#else /* HAVE_ARRAY_ELEM_INIT */
+
static int
compare_method_imap (const void *key, const void *elem)
{
return &icall_type_descs [nameslot - icall_type_names];
}
-#endif
+#endif /* HAVE_ARRAY_ELEM_INIT */
+
+#endif /* DISABLE_ICALL_TABLES */
/*
* we should probably export this as an helper (handle nested types).
return nspacelen + cnamelen;
}
+#ifdef DISABLE_ICALL_TABLES
+static void
+no_icall_table (void)
+{
+ g_assert_not_reached ();
+}
+#endif
+
gpointer
mono_lookup_internal_call (MonoMethod *method)
{
char mname [2048];
int typelen = 0, mlen, siglen;
gpointer res;
- const IcallTypeDesc *imap;
+#ifndef DISABLE_ICALL_TABLES
+ const IcallTypeDesc *imap = NULL;
+#endif
g_assert (method != NULL);
return NULL;
}
+#ifndef DISABLE_ICALL_TABLES
imap = find_class_icalls (mname);
+#endif
mname [typelen] = ':';
mname [typelen + 1] = ':';
return res;
}
+#ifdef DISABLE_ICALL_TABLES
+ mono_loader_unlock ();
+ /* Fail only when the result is actually used */
+ /* mono_marshal_get_native_wrapper () depends on this */
+ if (method->klass == mono_defaults.string_class && !strcmp (method->name, ".ctor"))
+ return ves_icall_System_String_ctor_RedirectToCreateString;
+ else
+ return no_icall_table;
+#else
/* it wasn't found in the static call tables */
if (!imap) {
mono_loader_unlock ();
mono_loader_unlock ();
return NULL;
+#endif
}
+#ifdef ENABLE_ICALL_SYMBOL_MAP
static int
func_cmp (gconstpointer key, gconstpointer p)
{
return (gsize)key - (gsize)*(gsize*)p;
}
+#endif
/*
* mono_lookup_icall_symbol:
const char*
mono_lookup_icall_symbol (MonoMethod *m)
{
+#ifdef DISABLE_ICALL_TABLES
+ g_assert_not_reached ();
+ return NULL;
+#else
#ifdef ENABLE_ICALL_SYMBOL_MAP
gpointer func;
int i;
g_assert_not_reached ();
return 0;
#endif
+#endif
}
static MonoType*
return jit_icall_hash_name;
}
+/*
+ * mono_lookup_jit_icall_symbol:
+ *
+ * Given the jit icall NAME, returns its C symbol if possible, or NULL.
+ */
+const char*
+mono_lookup_jit_icall_symbol (const char *name)
+{
+ MonoJitICallInfo *info;
+ const char *res = NULL;
+
+ mono_loader_lock ();
+ info = g_hash_table_lookup (jit_icall_hash_name, name);
+ if (info)
+ res = info->c_symbol;
+ mono_loader_unlock ();
+ return res;
+}
+
void
mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper)
{
}
MonoJitICallInfo *
-mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save)
+mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save, const char *c_symbol)
{
MonoJitICallInfo *info;
info->name = name;
info->func = func;
info->sig = sig;
+ info->c_symbol = c_symbol;
if (is_save) {
info->wrapper = func;
mono_loader_unlock ();
return info;
}
+
+MonoJitICallInfo *
+mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save)
+{
+ return mono_register_jit_icall_full (func, name, sig, is_save, NULL);
+}
+
projects / mono.git / blobdiff