-/*
- * icall.c:
+/**
+ * \file
*
* Authors:
* Dietmar Maurer (dietmar@ximian.com)
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/exception.h>
#include <mono/metadata/exception-internals.h>
-#include <mono/metadata/file-io.h>
+#include <mono/metadata/w32file.h>
#include <mono/metadata/console-io.h>
#include <mono/metadata/mono-route.h>
-#include <mono/metadata/socket-io.h>
+#include <mono/metadata/w32socket.h>
#include <mono/metadata/mono-endian.h>
#include <mono/metadata/tokentype.h>
#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/w32mutex.h>
#include <mono/metadata/w32semaphore.h>
#include <mono/metadata/w32event.h>
-#include <mono/io-layer/io-layer.h>
#include <mono/utils/monobitset.h>
#include <mono/utils/mono-time.h>
#include <mono/utils/mono-proclib.h>
#include <mono/utils/bsearch.h>
#include <mono/utils/mono-os-mutex.h>
#include <mono/utils/mono-threads.h>
+#include <mono/metadata/w32error.h>
+#include <mono/utils/w32api.h>
#include "decimal-ms.h"
#include "number-ms.h"
ICALL_EXPORT MonoReflectionAssemblyHandle ves_icall_System_Reflection_Assembly_GetCallingAssembly (MonoError *error);
/* Lazy class loading functions */
-static GENERATE_GET_CLASS_WITH_CACHE (system_version, System, Version)
-static GENERATE_GET_CLASS_WITH_CACHE (assembly_name, System.Reflection, AssemblyName)
-static GENERATE_GET_CLASS_WITH_CACHE (constructor_info, System.Reflection, ConstructorInfo)
-static GENERATE_GET_CLASS_WITH_CACHE (property_info, System.Reflection, PropertyInfo)
-static GENERATE_GET_CLASS_WITH_CACHE (event_info, System.Reflection, EventInfo)
-static GENERATE_GET_CLASS_WITH_CACHE (module, System.Reflection, Module)
+static GENERATE_GET_CLASS_WITH_CACHE (system_version, "System", "Version")
+static GENERATE_GET_CLASS_WITH_CACHE (assembly_name, "System.Reflection", "AssemblyName")
+static GENERATE_GET_CLASS_WITH_CACHE (constructor_info, "System.Reflection", "ConstructorInfo")
+static GENERATE_GET_CLASS_WITH_CACHE (property_info, "System.Reflection", "PropertyInfo")
+static GENERATE_GET_CLASS_WITH_CACHE (event_info, "System.Reflection", "EventInfo")
+static GENERATE_GET_CLASS_WITH_CACHE (module, "System.Reflection", "Module")
static MonoArrayHandle
type_array_from_modifiers (MonoImage *image, MonoType *type, int optional, MonoError *error);
static void
mono_class_init_checked (MonoClass *klass, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (!mono_class_init (klass))
mono_error_set_for_class_failure (error, klass);
gint64 i64 = 0;
gdouble r64 = 0;
- mono_error_init (&error);
+ error_init (&error);
if (value)
vc = value->vtable->klass;
if (mono_error_set_pending_exception (&error))
return NULL;
+ if (klass->element_class->byval_arg.type == MONO_TYPE_VOID) {
+ mono_set_pending_exception (mono_get_exception_not_supported ("Arrays of System.Void are not supported."));
+ return NULL;
+ }
+
if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint32, 0) != 0))
/* vectors are not the same as one dimensional arrays with no-zero bounds */
bounded = TRUE;
ICALL_EXPORT void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArrayHandle array, MonoClassField *field_handle, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClass *klass = mono_handle_class (array);
guint32 size = mono_array_element_size (klass);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_System_Object_GetType (MonoObjectHandle obj, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (obj);
MonoClass *klass = mono_handle_class (obj);
#ifndef DISABLE_REMOTING
gboolean type_resolve = FALSE;
MonoImage *rootimage = NULL;
- mono_error_init (error);
+ error_init (error);
/*
* We must compute the calling assembly as type loading must happen under a metadata context.
MonoBoolean ignoreCase,
MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoTypeNameParse info;
gboolean parsedOk;
MonoAssembly *caller_assembly;
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_System_Type_internal_from_handle (MonoType *handle, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get ();
return mono_type_get_object_handle (domain, handle, error);
ICALL_EXPORT guint32
ves_icall_type_GetTypeCodeInternal (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
int t = type->type;
ICALL_EXPORT guint32
ves_icall_RuntimeTypeHandle_type_is_assignable_from (MonoReflectionTypeHandle ref_type, MonoReflectionTypeHandle ref_c, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
g_assert (!MONO_HANDLE_IS_NULL (ref_type));
ICALL_EXPORT guint32
ves_icall_RuntimeTypeHandle_IsInstanceOfType (MonoReflectionTypeHandle ref_type, MonoObjectHandle obj, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
mono_class_init_checked (klass, error);
ICALL_EXPORT guint32
ves_icall_RuntimeTypeHandle_GetAttributes (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
return mono_class_get_flags (klass);
ICALL_EXPORT MonoReflectionMarshalAsAttributeHandle
ves_icall_System_Reflection_FieldInfo_get_marshal_info (MonoReflectionFieldHandle field_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (field_h);
MonoClassField *field = MONO_HANDLE_GETVAL (field_h, field);
MonoClass *klass = field->parent;
g_assert (handle);
- mono_error_init (error);
+ error_init (error);
if (!type) {
klass = handle->parent;
g_assert (handle);
- mono_error_init (error);
+ error_init (error);
if (!type) {
klass = handle->parent;
ICALL_EXPORT MonoReflectionPropertyHandle
ves_icall_System_Reflection_PropertyInfo_internal_from_handle_type (MonoProperty *handle, MonoType *type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClass *klass;
g_assert (handle);
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionFieldHandle field_h, MonoBoolean optional, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClassField *field = MONO_HANDLE_GETVAL (field_h, field);
MonoType *type = mono_field_get_type_checked (field, error);
}
ICALL_EXPORT void
-ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
+ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info, MonoError *error)
{
- MonoError error;
- MonoReflectionType *rt;
MonoDomain *domain = mono_domain_get ();
- MonoMethodSignature* sig;
- sig = mono_method_signature_checked (method, &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return;
- }
+ MonoMethodSignature* sig = mono_method_signature_checked (method, error);
+ return_if_nok (error);
- rt = mono_type_get_object_checked (domain, &method->klass->byval_arg, &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return;
- }
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &method->klass->byval_arg, error);
+ return_if_nok (error);
- MONO_STRUCT_SETREF (info, parent, rt);
+ MONO_STRUCT_SETREF (info, parent, MONO_HANDLE_RAW (rt));
- rt = mono_type_get_object_checked (domain, sig->ret, &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return;
- }
+ MONO_HANDLE_ASSIGN (rt, mono_type_get_object_handle (domain, sig->ret, error));
+ return_if_nok (error);
- MONO_STRUCT_SETREF (info, ret, rt);
+ MONO_STRUCT_SETREF (info, ret, MONO_HANDLE_RAW (rt));
info->attrs = method->flags;
info->implattrs = method->iflags;
+ guint32 callconv;
if (sig->call_convention == MONO_CALL_DEFAULT)
- info->callconv = sig->sentinelpos >= 0 ? 2 : 1;
+ callconv = sig->sentinelpos >= 0 ? 2 : 1;
else {
if (sig->call_convention == MONO_CALL_VARARG || sig->sentinelpos >= 0)
- info->callconv = 2;
+ callconv = 2;
else
- info->callconv = 1;
+ callconv = 1;
}
- info->callconv |= (sig->hasthis << 5) | (sig->explicit_this << 6);
+ callconv |= (sig->hasthis << 5) | (sig->explicit_this << 6);
+ info->callconv = callconv;
}
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_MonoMethodInfo_get_parameter_info (MonoMethod *method, MonoReflectionMethodHandle member, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get ();
MonoReflectionTypeHandle reftype = MONO_HANDLE_NEW (MonoReflectionType, NULL);
ICALL_EXPORT MonoReflectionMarshalAsAttributeHandle
ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get ();
MonoReflectionMarshalAsAttributeHandle res = MONO_HANDLE_NEW (MonoReflectionMarshalAsAttribute, NULL);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_MonoField_GetParentType (MonoReflectionFieldHandle field, MonoBoolean declaring, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (field);
MonoClass *parent;
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_MonoField_ResolveType (MonoReflectionFieldHandle ref_field, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_field);
MonoClassField *field = MONO_HANDLE_GETVAL (ref_field, field);
MonoType *type = mono_field_get_type_checked (field, error);
} PInfo;
ICALL_EXPORT void
-ves_icall_MonoPropertyInfo_get_property_info (const MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info)
+ves_icall_MonoPropertyInfo_get_property_info (MonoReflectionPropertyHandle property, MonoPropertyInfo *info, PInfo req_info, MonoError *error)
{
- MonoError error;
- MonoReflectionType *rt;
- MonoReflectionMethod *rm;
- MonoDomain *domain = mono_object_domain (property);
- const MonoProperty *pproperty = property->property;
+ error_init (error);
+ MonoDomain *domain = MONO_HANDLE_DOMAIN (property);
+ const MonoProperty *pproperty = MONO_HANDLE_GETVAL (property, property);
if ((req_info & PInfo_ReflectedType) != 0) {
- rt = mono_type_get_object_checked (domain, &property->klass->byval_arg, &error);
- if (mono_error_set_pending_exception (&error))
- return;
+ MonoClass *klass = MONO_HANDLE_GETVAL (property, klass);
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &klass->byval_arg, error);
+ return_if_nok (error);
- MONO_STRUCT_SETREF (info, parent, rt);
+ MONO_STRUCT_SETREF (info, parent, MONO_HANDLE_RAW (rt));
}
if ((req_info & PInfo_DeclaringType) != 0) {
- rt = mono_type_get_object_checked (domain, &pproperty->parent->byval_arg, &error);
- if (mono_error_set_pending_exception (&error))
- return;
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &pproperty->parent->byval_arg, error);
+ return_if_nok (error);
- MONO_STRUCT_SETREF (info, declaring_type, rt);
+ MONO_STRUCT_SETREF (info, declaring_type, MONO_HANDLE_RAW (rt));
}
- if ((req_info & PInfo_Name) != 0)
- MONO_STRUCT_SETREF (info, name, mono_string_new (domain, pproperty->name));
+ if ((req_info & PInfo_Name) != 0) {
+ MonoStringHandle name = mono_string_new_handle (domain, pproperty->name, error);
+ return_if_nok (error);
+
+ MONO_STRUCT_SETREF (info, name, MONO_HANDLE_RAW (name));
+ }
if ((req_info & PInfo_Attributes) != 0)
info->attrs = pproperty->attrs;
if ((req_info & PInfo_GetMethod) != 0) {
+ MonoClass *property_klass = MONO_HANDLE_GETVAL (property, klass);
+ MonoReflectionMethodHandle rm;
if (pproperty->get &&
(((pproperty->get->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) ||
- pproperty->get->klass == property->klass)) {
- rm = mono_method_get_object_checked (domain, pproperty->get, property->klass, &error);
- if (mono_error_set_pending_exception (&error))
- return;
+ pproperty->get->klass == property_klass)) {
+ rm = mono_method_get_object_handle (domain, pproperty->get, property_klass, error);
+ return_if_nok (error);
} else {
- rm = NULL;
+ rm = MONO_HANDLE_NEW (MonoReflectionMethod, NULL);
}
- MONO_STRUCT_SETREF (info, get, rm);
+ MONO_STRUCT_SETREF (info, get, MONO_HANDLE_RAW (rm));
}
if ((req_info & PInfo_SetMethod) != 0) {
+ MonoClass *property_klass = MONO_HANDLE_GETVAL (property, klass);
+ MonoReflectionMethodHandle rm;
if (pproperty->set &&
(((pproperty->set->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) ||
- pproperty->set->klass == property->klass)) {
- rm = mono_method_get_object_checked (domain, pproperty->set, property->klass, &error);
- if (mono_error_set_pending_exception (&error))
- return;
+ pproperty->set->klass == property_klass)) {
+ rm = mono_method_get_object_handle (domain, pproperty->set, property_klass, error);
+ return_if_nok (error);
} else {
- rm = NULL;
+ rm = MONO_HANDLE_NEW (MonoReflectionMethod, NULL);
}
- MONO_STRUCT_SETREF (info, set, rm);
+ MONO_STRUCT_SETREF (info, set, MONO_HANDLE_RAW (rm));
}
/*
* There may be other methods defined for properties, though, it seems they are not exposed
ICALL_EXPORT MonoArrayHandle
ves_icall_RuntimeType_GetInterfaces (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
set_interface_map_data_method_object (MonoDomain *domain, MonoMethod *method, MonoClass *iclass, int ioffset, MonoClass *klass, MonoArrayHandle targets, MonoArrayHandle methods, int i, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoReflectionMethodHandle member = mono_method_get_object_handle (domain, method, iclass, error);
if (!is_ok (error))
goto leave;
ICALL_EXPORT void
ves_icall_RuntimeType_GetInterfaceMapData (MonoReflectionTypeHandle ref_type, MonoReflectionTypeHandle ref_iface, MonoArrayHandleOut targets, MonoArrayHandleOut methods, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
MonoType *iface = MONO_HANDLE_GETVAL (ref_iface, type);
ICALL_EXPORT void
ves_icall_RuntimeType_GetPacking (MonoReflectionTypeHandle ref_type, guint32 *packing, guint32 *size, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeTypeHandle_GetElementType (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeTypeHandle_GetBaseType (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
ICALL_EXPORT MonoBoolean
ves_icall_RuntimeTypeHandle_IsPointer (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
return type->type == MONO_TYPE_PTR;
}
ICALL_EXPORT MonoBoolean
ves_icall_RuntimeTypeHandle_IsPrimitive (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
return (!type->byref && (((type->type >= MONO_TYPE_BOOLEAN) && (type->type <= MONO_TYPE_R8)) || (type->type == MONO_TYPE_I) || (type->type == MONO_TYPE_U)));
}
+ICALL_EXPORT MonoBoolean
+ves_icall_RuntimeTypeHandle_HasReferences (MonoReflectionTypeHandle ref_type, MonoError *error)
+{
+ error_init (error);
+ MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
+ MonoClass *klass;
+
+ klass = mono_class_from_mono_type (type);
+ mono_class_init (klass);
+ return klass->has_references;
+}
+
ICALL_EXPORT MonoBoolean
ves_icall_RuntimeTypeHandle_IsByRef (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
return type->byref;
}
ICALL_EXPORT MonoBoolean
ves_icall_RuntimeTypeHandle_IsComObject (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
mono_class_init_checked (klass, error);
ICALL_EXPORT guint32
ves_icall_reflection_get_token (MonoObjectHandle obj, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return mono_reflection_get_token_checked (obj, error);
}
ICALL_EXPORT MonoReflectionModuleHandle
ves_icall_RuntimeTypeHandle_GetModule (MonoReflectionTypeHandle type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (type);
MonoType *t = MONO_HANDLE_GETVAL (type, type);
MonoClass *klass = mono_class_from_mono_type (t);
ICALL_EXPORT MonoReflectionAssemblyHandle
ves_icall_RuntimeTypeHandle_GetAssembly (MonoReflectionTypeHandle type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get ();
MonoType *t = MONO_HANDLE_GETVAL (type, type);
MonoClass *klass = mono_class_from_mono_type (t);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeType_get_DeclaringType (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get ();
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass;
ICALL_EXPORT gint32
ves_icall_RuntimeTypeHandle_GetArrayRank (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
if (type->type != MONO_TYPE_ARRAY && type->type != MONO_TYPE_SZARRAY) {
set_type_object_in_array (MonoDomain *domain, MonoType *type, MonoArrayHandle dest, int i, MonoError *error)
{
HANDLE_FUNCTION_ENTER();
- mono_error_init (error);
+ error_init (error);
MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, type, error);
if (!is_ok (error))
goto leave;
ICALL_EXPORT MonoArrayHandle
ves_icall_RuntimeType_GetGenericArguments (MonoReflectionTypeHandle ref_type, MonoBoolean runtimeTypeArray, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
ICALL_EXPORT gboolean
ves_icall_RuntimeTypeHandle_IsGenericTypeDefinition (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (!IS_MONOTYPE (MONO_HANDLE_RAW(ref_type)))
return FALSE;
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeTypeHandle_GetGenericTypeDefinition_impl (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoReflectionTypeHandle ret = MONO_HANDLE_NEW (MonoReflectionType, NULL);
if (mono_class_is_ginst (klass)) {
MonoClass *generic_class = mono_class_get_generic_class (klass)->container_class;
- guint32 ref_info_handle = mono_class_get_ref_info_handle (klass);
+ guint32 ref_info_handle = mono_class_get_ref_info_handle (generic_class);
if (generic_class->wastypebuilder && ref_info_handle) {
MonoObjectHandle tb = mono_gchandle_get_target_handle (ref_info_handle);
return ret;
}
-ICALL_EXPORT MonoReflectionType*
-ves_icall_RuntimeType_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
+ICALL_EXPORT MonoReflectionTypeHandle
+ves_icall_RuntimeType_MakeGenericType (MonoReflectionTypeHandle reftype, MonoArrayHandle type_array, MonoError *error)
{
- MonoError error;
- MonoReflectionType *ret;
- MonoClass *klass;
- MonoType *geninst, **types;
- int i, count;
+ error_init (error);
+ MonoDomain *domain = MONO_HANDLE_DOMAIN (reftype);
- g_assert (IS_MONOTYPE (type));
- mono_class_init_checked (mono_class_from_mono_type (type->type), &error);
- if (mono_error_set_pending_exception (&error))
- return NULL;
+ g_assert (IS_MONOTYPE_HANDLE (reftype));
+ MonoType *type = MONO_HANDLE_GETVAL (reftype, type);
+ mono_class_init_checked (mono_class_from_mono_type (type), error);
+ if (!is_ok (error))
+ return MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE);
- count = mono_array_length (type_array);
- types = g_new0 (MonoType *, count);
+ int count = mono_array_handle_length (type_array);
+ MonoType **types = g_new0 (MonoType *, count);
- for (i = 0; i < count; i++) {
- MonoReflectionType *t = (MonoReflectionType *)mono_array_get (type_array, gpointer, i);
- types [i] = t->type;
+ MonoReflectionTypeHandle t = MONO_HANDLE_NEW (MonoReflectionType, NULL);
+ for (int i = 0; i < count; i++) {
+ MONO_HANDLE_ARRAY_GETREF (t, type_array, i);
+ types [i] = MONO_HANDLE_GETVAL (t, type);
}
- geninst = mono_reflection_bind_generic_parameters (type, count, types, &error);
+ MonoType *geninst = mono_reflection_bind_generic_parameters (reftype, count, types, error);
g_free (types);
if (!geninst) {
- mono_error_set_pending_exception (&error);
- return NULL;
+ return MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE);
}
- klass = mono_class_from_mono_type (geninst);
+ MonoClass *klass = mono_class_from_mono_type (geninst);
/*we might inflate to the GTD*/
if (mono_class_is_ginst (klass) && !mono_verifier_class_is_valid_generic_instantiation (klass)) {
- mono_set_pending_exception (mono_get_exception_argument ("typeArguments", "Invalid generic arguments"));
- return NULL;
+ mono_error_set_argument (error, "typeArguments", "Invalid generic arguments");
+ return MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE);
}
- ret = mono_type_get_object_checked (mono_object_domain (type), geninst, &error);
- mono_error_set_pending_exception (&error);
-
- return ret;
+ return mono_type_get_object_handle (domain, geninst, error);
}
ICALL_EXPORT gboolean
ves_icall_RuntimeTypeHandle_HasInstantiation (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClass *klass;
if (!IS_MONOTYPE (MONO_HANDLE_RAW (ref_type)))
ICALL_EXPORT gint32
ves_icall_RuntimeType_GetGenericParameterPosition (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (!IS_MONOTYPE_HANDLE (ref_type))
return -1;
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
ICALL_EXPORT MonoGenericParamInfo *
ves_icall_RuntimeTypeHandle_GetGenericParameterInfo (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
return mono_generic_param_info (type->data.generic_param);
}
MonoReflectionMethodHandle generic,
MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
ICALL_EXPORT MonoReflectionMethodHandle
ves_icall_RuntimeType_get_DeclaringMethod (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoReflectionMethodHandle ret = MONO_HANDLE_NEW (MonoReflectionMethod, NULL);
ICALL_EXPORT MonoBoolean
ves_icall_System_RuntimeType_IsTypeExportedToWindowsRuntime (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
mono_error_set_not_implemented (error, "%s", "");
return FALSE;
}
ICALL_EXPORT MonoBoolean
ves_icall_System_RuntimeType_IsWindowsRuntimeObjectType (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
mono_error_set_not_implemented (error, "%s", "");
return FALSE;
}
ICALL_EXPORT void
-ves_icall_MonoMethod_GetPInvoke (MonoReflectionMethod *method, int* flags, MonoString** entry_point, MonoString** dll_name)
+ves_icall_MonoMethod_GetPInvoke (MonoReflectionMethodHandle ref_method, int* flags, MonoStringHandleOut entry_point, MonoStringHandleOut dll_name, MonoError *error)
{
MonoDomain *domain = mono_domain_get ();
- MonoImage *image = method->method->klass->image;
- MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)method->method;
+ MonoMethod *method = MONO_HANDLE_GETVAL (ref_method, method);
+ MonoImage *image = method->klass->image;
+ MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)method;
MonoTableInfo *tables = image->tables;
MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP];
MonoTableInfo *mr = &tables [MONO_TABLE_MODULEREF];
const char *import = NULL;
const char *scope = NULL;
+ error_init (error);
+
if (image_is_dynamic (image)) {
MonoReflectionMethodAux *method_aux =
- (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)image)->method_aux_hash, method->method);
+ (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)image)->method_aux_hash, method);
if (method_aux) {
import = method_aux->dllentry;
scope = method_aux->dll;
}
if (!import || !scope) {
- mono_set_pending_exception (mono_get_exception_argument ("method", "System.Reflection.Emit method with invalid pinvoke information"));
+ mono_error_set_argument (error, "method", "System.Refleciton.Emit method with invalid pinvoke information");
return;
}
}
}
*flags = piinfo->piflags;
- *entry_point = mono_string_new (domain, import);
- *dll_name = mono_string_new (domain, scope);
+ MONO_HANDLE_ASSIGN (entry_point, mono_string_new_handle (domain, import, error));
+ return_if_nok (error);
+ MONO_HANDLE_ASSIGN (dll_name, mono_string_new_handle (domain, scope, error));
}
-ICALL_EXPORT MonoReflectionMethod *
-ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method)
+ICALL_EXPORT MonoReflectionMethodHandle
+ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethodHandle ref_method, MonoError *error)
{
- MonoMethodInflated *imethod;
- MonoMethod *result;
- MonoReflectionMethod *ret = NULL;
- MonoError error;
+ error_init (error);
+ MonoMethod *method = MONO_HANDLE_GETVAL (ref_method, method);
- if (method->method->is_generic)
- return method;
+ if (method->is_generic)
+ return ref_method;
- if (!method->method->is_inflated)
- return NULL;
+ if (!method->is_inflated)
+ return MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE);
- imethod = (MonoMethodInflated *) method->method;
+ MonoMethodInflated *imethod = (MonoMethodInflated *) method;
- result = imethod->declaring;
+ MonoMethod *result = imethod->declaring;
/* Not a generic method. */
if (!result->is_generic)
- return NULL;
+ return MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE);
- if (image_is_dynamic (method->method->klass->image)) {
- MonoDynamicImage *image = (MonoDynamicImage*)method->method->klass->image;
- MonoReflectionMethod *res;
+ if (image_is_dynamic (method->klass->image)) {
+ MonoDynamicImage *image = (MonoDynamicImage*)method->klass->image;
/*
* FIXME: Why is this stuff needed at all ? Why can't the code below work for
* the dynamic case as well ?
*/
mono_image_lock ((MonoImage*)image);
- res = (MonoReflectionMethod *)mono_g_hash_table_lookup (image->generic_def_objects, imethod);
+ MonoReflectionMethodHandle res = MONO_HANDLE_NEW (MonoReflectionMethod, mono_g_hash_table_lookup (image->generic_def_objects, imethod));
mono_image_unlock ((MonoImage*)image);
- if (res)
+ if (!MONO_HANDLE_IS_NULL (res))
return res;
}
MonoClass *klass = ((MonoMethod *) imethod)->klass;
/*Generic methods gets the context of the GTD.*/
if (mono_class_get_context (klass)) {
- result = mono_class_inflate_generic_method_full_checked (result, klass, mono_class_get_context (klass), &error);
- if (!mono_error_ok (&error))
- goto leave;
+ result = mono_class_inflate_generic_method_full_checked (result, klass, mono_class_get_context (klass), error);
+ return_val_if_nok (error, MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE));
}
}
- ret = mono_method_get_object_checked (mono_object_domain (method), result, NULL, &error);
-leave:
- if (!mono_error_ok (&error))
- mono_error_set_pending_exception (&error);
- return ret;
+ return mono_method_get_object_handle (MONO_HANDLE_DOMAIN (ref_method), result, NULL, error);
}
ICALL_EXPORT gboolean
-ves_icall_MonoMethod_get_IsGenericMethod (MonoReflectionMethod *method)
+ves_icall_MonoMethod_get_IsGenericMethod (MonoReflectionMethodHandle ref_method, MonoError *erro)
{
- return mono_method_signature (method->method)->generic_param_count != 0;
+ MonoMethod *method = MONO_HANDLE_GETVAL (ref_method, method);
+ return mono_method_signature (method)->generic_param_count != 0;
}
ICALL_EXPORT gboolean
-ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method)
+ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethodHandle ref_method, MonoError *Error)
{
- return method->method->is_generic;
+ MonoMethod *method = MONO_HANDLE_GETVAL (ref_method, method);
+ return method->is_generic;
}
-ICALL_EXPORT MonoArray*
-ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method)
+static gboolean
+set_array_generic_argument_handle_inflated (MonoDomain *domain, MonoGenericInst *inst, int i, MonoArrayHandle arr, MonoError *error)
{
- MonoError error;
- MonoReflectionType *rt;
- MonoArray *res;
- MonoDomain *domain;
- int count, i;
+ HANDLE_FUNCTION_ENTER ();
+ error_init (error);
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, inst->type_argv [i], error);
+ if (!is_ok (error))
+ goto leave;
+ MONO_HANDLE_ARRAY_SETREF (arr, i, rt);
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
+}
+
+static gboolean
+set_array_generic_argument_handle_gparam (MonoDomain *domain, MonoGenericContainer *container, int i, MonoArrayHandle arr, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER ();
+ error_init (error);
+ MonoGenericParam *param = mono_generic_container_get_param (container, i);
+ MonoClass *pklass = mono_class_from_generic_parameter_internal (param);
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &pklass->byval_arg, error);
+ if (!is_ok (error))
+ goto leave;
+ MONO_HANDLE_ARRAY_SETREF (arr, i, rt);
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
+}
- domain = mono_object_domain (method);
+ICALL_EXPORT MonoArrayHandle
+ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethodHandle ref_method, MonoError *error)
+{
+ error_init (error);
+ MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_method);
+ MonoMethod *method = MONO_HANDLE_GETVAL (ref_method, method);
- if (method->method->is_inflated) {
- MonoGenericInst *inst = mono_method_get_context (method->method)->method_inst;
+ if (method->is_inflated) {
+ MonoGenericInst *inst = mono_method_get_context (method)->method_inst;
if (inst) {
- count = inst->type_argc;
- res = mono_array_new_checked (domain, mono_defaults.systemtype_class, count, &error);
- if (mono_error_set_pending_exception (&error))
- return NULL;
-
- for (i = 0; i < count; i++) {
- rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error);
- if (mono_error_set_pending_exception (&error))
- return NULL;
+ int count = inst->type_argc;
+ MonoArrayHandle res = mono_array_new_handle (domain, mono_defaults.systemtype_class, count, error);
+ return_val_if_nok (error, MONO_HANDLE_CAST (MonoArray, NULL_HANDLE));
- mono_array_setref (res, i, rt);
+ for (int i = 0; i < count; i++) {
+ if (!set_array_generic_argument_handle_inflated (domain, inst, i, res, error))
+ break;
}
-
+ return_val_if_nok (error, MONO_HANDLE_CAST (MonoArray, NULL_HANDLE));
return res;
}
}
- count = mono_method_signature (method->method)->generic_param_count;
- res = mono_array_new_checked (domain, mono_defaults.systemtype_class, count, &error);
- if (mono_error_set_pending_exception (&error))
- return NULL;
-
- for (i = 0; i < count; i++) {
- MonoGenericContainer *container = mono_method_get_generic_container (method->method);
- MonoGenericParam *param = mono_generic_container_get_param (container, i);
- MonoClass *pklass = mono_class_from_generic_parameter_internal (param);
-
- rt = mono_type_get_object_checked (domain, &pklass->byval_arg, &error);
- if (mono_error_set_pending_exception (&error))
- return NULL;
+ int count = mono_method_signature (method)->generic_param_count;
+ MonoArrayHandle res = mono_array_new_handle (domain, mono_defaults.systemtype_class, count, error);
+ return_val_if_nok (error, MONO_HANDLE_CAST (MonoArray, NULL_HANDLE));
- mono_array_setref (res, i, rt);
+ MonoGenericContainer *container = mono_method_get_generic_container (method);
+ for (int i = 0; i < count; i++) {
+ if (!set_array_generic_argument_handle_gparam (domain, container, i, res, error))
+ break;
}
-
+ return_val_if_nok (error, MONO_HANDLE_CAST (MonoArray, NULL_HANDLE));
return res;
}
static void
get_enum_field (MonoDomain *domain, MonoArrayHandle names, MonoArrayHandle values, int base_type, MonoClassField *field, guint* j, guint64 *previous_value, gboolean *sorted, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
HANDLE_FUNCTION_ENTER();
guint64 field_value;
const char *p;
guint64 previous_value = 0;
gboolean sorted = TRUE;
- mono_error_init (error);
+ error_init (error);
mono_class_init_checked (enumc, error);
return_val_if_nok (error, FALSE);
ICALL_EXPORT GPtrArray*
ves_icall_RuntimeType_GetFields_native (MonoReflectionTypeHandle ref_type, char *utf8_name, guint32 bflags, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
if (type->byref) {
array = g_ptr_array_new ();
startklass = klass;
- mono_error_init (error);
+ error_init (error);
if (name != NULL)
compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp;
ICALL_EXPORT GPtrArray*
ves_icall_RuntimeType_GetMethodsByName_native (MonoReflectionTypeHandle ref_type, const char *mname, guint32 bflags, MonoBoolean ignore_case, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
ICALL_EXPORT GPtrArray*
ves_icall_RuntimeType_GetConstructors_native (MonoReflectionTypeHandle ref_type, guint32 bflags, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
if (type->byref) {
return g_ptr_array_new ();
ICALL_EXPORT GPtrArray*
ves_icall_RuntimeType_GetPropertiesByName_native (MonoReflectionTypeHandle ref_type, gchar *propname, guint32 bflags, MonoBoolean ignore_case, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
ICALL_EXPORT GPtrArray*
ves_icall_RuntimeType_GetEvents_native (MonoReflectionTypeHandle ref_type, char *utf8_name, guint32 bflags, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
if (type->byref) {
ICALL_EXPORT GPtrArray *
ves_icall_RuntimeType_GetNestedTypes_native (MonoReflectionTypeHandle ref_type, char *str, guint32 bflags, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
if (type->byref) {
get_type_from_module_builder_module (MonoArrayHandle modules, int i, MonoTypeNameParse *info, MonoBoolean ignoreCase, gboolean *type_resolve, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoType *type = NULL;
MonoReflectionModuleBuilderHandle mb = MONO_HANDLE_NEW (MonoReflectionModuleBuilder, NULL);
MONO_HANDLE_ARRAY_GETREF (mb, modules, i);
get_type_from_module_builder_loaded_modules (MonoArrayHandle loaded_modules, int i, MonoTypeNameParse *info, MonoBoolean ignoreCase, gboolean *type_resolve, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoType *type = NULL;
MonoReflectionModuleHandle mod = MONO_HANDLE_NEW (MonoReflectionModule, NULL);
MONO_HANDLE_ARRAY_GETREF (mod, loaded_modules, i);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssemblyHandle assembly_h, MonoReflectionModuleHandle module, MonoStringHandle name, MonoBoolean throwOnError, MonoBoolean ignoreCase, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoTypeNameParse info;
gboolean type_resolve;
ICALL_EXPORT MonoStringHandle
ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssemblyHandle assembly, MonoBoolean escaped, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly);
MonoAssembly *mass = MONO_HANDLE_GETVAL (assembly, assembly);
gchar *absolute;
ICALL_EXPORT MonoBoolean
ves_icall_System_Reflection_Assembly_get_global_assembly_cache (MonoReflectionAssemblyHandle assembly, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoAssembly *mass = MONO_HANDLE_GETVAL (assembly,assembly);
return mass->in_gac;
ICALL_EXPORT MonoBoolean
ves_icall_System_Reflection_Assembly_get_ReflectionOnly (MonoReflectionAssemblyHandle assembly_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
return assembly->ref_only;
}
ICALL_EXPORT MonoReflectionMethodHandle
ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssemblyHandle assembly_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly_h);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoMethod *method;
ICALL_EXPORT MonoReflectionModuleHandle
ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAssemblyHandle assembly, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly);
MonoAssembly *a = MONO_HANDLE_GETVAL (assembly, assembly);
return mono_module_get_object_handle (domain, a->image, error);
add_manifest_resource_name_to_array (MonoDomain *domain, MonoImage *image, MonoTableInfo *table, int i, MonoArrayHandle dest, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
const char *val = mono_metadata_string_heap (image, mono_metadata_decode_row_col (table, i, MONO_MANIFEST_NAME));
MonoStringHandle str = mono_string_new_handle (domain, val, error);
if (!is_ok (error))
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssemblyHandle assembly_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly_h);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoTableInfo *table = &assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
static MonoAssemblyName*
create_referenced_assembly_name (MonoDomain *domain, MonoImage *image, MonoTableInfo *t, int i, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoAssemblyName *aname = g_new0 (MonoAssemblyName, 1);
mono_assembly_get_assemblyref (image, i, aname);
ICALL_EXPORT GPtrArray*
ves_icall_System_Reflection_Assembly_InternalGetReferencedAssemblies (MonoReflectionAssemblyHandle assembly, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly);
MonoAssembly *ass = MONO_HANDLE_GETVAL(assembly, assembly);
MonoImage *image = ass->image;
ICALL_EXPORT void *
ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssemblyHandle assembly_h, MonoStringHandle name, gint32 *size, MonoReflectionModuleHandleOut ref_module, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly_h);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoTableInfo *table = &assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
ICALL_EXPORT gboolean
ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflectionAssemblyHandle assembly_h, MonoStringHandle name, MonoManifestResourceInfoHandle info_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return get_manifest_resource_info_internal (assembly_h, name, info_h, error);
}
add_filename_to_files_array (MonoDomain *domain, MonoAssembly * assembly, MonoTableInfo *table, int i, MonoArrayHandle dest, int dest_idx, MonoError *error)
{
HANDLE_FUNCTION_ENTER();
- mono_error_init (error);
+ error_init (error);
const char *val = mono_metadata_string_heap (assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME));
char *n = g_concat_dir_and_file (assembly->basedir, val);
MonoStringHandle str = mono_string_new_handle (domain, n, error);
ICALL_EXPORT MonoObjectHandle
ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssemblyHandle assembly_h, MonoStringHandle name, MonoBoolean resource_modules, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly_h);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoTableInfo *table = &assembly->image->tables [MONO_TABLE_FILE];
add_module_to_modules_array (MonoDomain *domain, MonoArrayHandle dest, int *dest_idx, MonoImage* module, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
if (module) {
MonoReflectionModuleHandle rm = mono_module_get_object_handle (domain, module, error);
if (!is_ok (error))
add_file_to_modules_array (MonoDomain *domain, MonoArrayHandle dest, int dest_idx, MonoImage *image, MonoTableInfo *table, int table_idx, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
guint32 cols [MONO_FILE_SIZE];
mono_metadata_decode_row (table, table_idx, cols, MONO_FILE_SIZE);
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssemblyHandle assembly_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get();
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoClass *klass;
ICALL_EXPORT MonoReflectionMethodHandle
ves_icall_GetCurrentMethod (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoMethod *m = mono_method_get_last_managed ();
ICALL_EXPORT MonoReflectionMethodHandle
ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType_native (MonoMethod *method, MonoType *type, MonoBoolean generic_check, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClass *klass;
if (type && generic_check) {
klass = mono_class_from_mono_type (type);
ICALL_EXPORT MonoReflectionMethodBodyHandle
ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod *method, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return mono_method_body_get_object_handle (mono_domain_get (), method, error);
}
ICALL_EXPORT MonoReflectionAssemblyHandle
ves_icall_System_Reflection_Assembly_GetExecutingAssembly (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoMethod *dest = NULL;
mono_stack_walk_no_il (get_executing, &dest);
ICALL_EXPORT MonoReflectionAssemblyHandle
ves_icall_System_Reflection_Assembly_GetEntryAssembly (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain* domain = mono_domain_get ();
ICALL_EXPORT MonoReflectionAssemblyHandle
ves_icall_System_Reflection_Assembly_GetCallingAssembly (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoMethod *m;
MonoMethod *dest;
ICALL_EXPORT int
vell_icall_RuntimeType_get_core_clr_security_level (MonoReflectionTypeHandle rfield, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (rfield, type);
MonoClass *klass = mono_class_from_mono_type (type);
}
ICALL_EXPORT int
-ves_icall_MonoMethod_get_core_clr_security_level (MonoReflectionMethod *rfield)
+ves_icall_MonoMethod_get_core_clr_security_level (MonoReflectionMethodHandle rfield, MonoError *error)
{
- MonoMethod *method = rfield->method;
+ error_init (error);
+ MonoMethod *method = MONO_HANDLE_GETVAL (rfield, method);
return mono_security_core_clr_method_level (method, TRUE);
}
ICALL_EXPORT MonoStringHandle
ves_icall_System_Reflection_Assembly_get_fullName (MonoReflectionAssemblyHandle assembly, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly);
MonoAssembly *mass = MONO_HANDLE_GETVAL (assembly, assembly);
gchar *name;
MonoImage *image;
char *dirname;
- mono_error_init (error);
+ error_init (error);
filename = mono_string_handle_to_utf8 (fname, error);
return_if_nok (error);
replace_shadow_path (mono_domain_get (), dirname, &filename);
g_free (dirname);
- image = mono_image_open (filename, &status);
+ image = mono_image_open_full (filename, &status, TRUE);
if (!image){
if (status == MONO_IMAGE_IMAGE_INVALID)
ves_icall_System_Reflection_Assembly_LoadPermissions (MonoReflectionAssemblyHandle assembly_h,
char **minimum, guint32 *minLength, char **optional, guint32 *optLength, char **refused, guint32 *refLength, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoBoolean result = FALSE;
MonoDeclSecurityEntry entry;
static void
image_get_type (MonoDomain *domain, MonoImage *image, MonoTableInfo *tdef, int table_idx, int count, MonoArrayHandle res, MonoArrayHandle exceptions, MonoBoolean exportedOnly, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
HANDLE_FUNCTION_ENTER ();
MonoError klass_error;
MonoClass *klass = mono_class_get_checked (image, table_idx | MONO_TOKEN_TYPE_DEF, &klass_error);
MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF];
int i, count;
- mono_error_init (error);
+ error_init (error);
/* we start the count from 1 because we skip the special type <Module> */
if (exportedOnly) {
append_module_types (MonoDomain *domain, MonoArrayHandleOut res, MonoArrayHandleOut exceptions, MonoImage *image, MonoBoolean exportedOnly, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoArrayHandle ex2 = MONO_HANDLE_NEW (MonoArray, NULL);
MonoArrayHandle res2 = mono_module_get_types (domain, image, ex2, exportedOnly, error);
if (!is_ok (error))
{
HANDLE_FUNCTION_ENTER ();
MonoError unboxed_error;
- mono_error_init (&unboxed_error);
+ error_init (&unboxed_error);
mono_error_set_for_class_failure (&unboxed_error, klass);
MonoExceptionHandle exc = MONO_HANDLE_NEW (MonoException, mono_error_convert_to_exception (&unboxed_error));
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModuleHandle module, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoImage *image = MONO_HANDLE_GETVAL (module, image);
MonoDomain *domain = MONO_HANDLE_DOMAIN (module);
module_resolve_type_token (MonoImage *image, guint32 token, MonoArrayHandle type_args, MonoArrayHandle method_args, MonoResolveTokenError *resolve_error, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoType *result = NULL;
MonoClass *klass;
int table = mono_metadata_token_table (token);
module_resolve_method_token (MonoImage *image, guint32 token, MonoArrayHandle type_args, MonoArrayHandle method_args, MonoResolveTokenError *resolve_error, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoMethod *method = NULL;
int table = mono_metadata_token_table (token);
int index = mono_metadata_token_index (token);
MonoGenericContext context;
MonoClassField *field = NULL;
- mono_error_init (error);
+ error_init (error);
*resolve_error = ResolveTokenError_Other;
/* Validate token */
{
int table = mono_metadata_token_table (token);
- mono_error_init (merror);
+ error_init (merror);
*error = ResolveTokenError_Other;
switch (table) {
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *resolve_error, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
int table = mono_metadata_token_table (token);
int idx = mono_metadata_token_index (token);
MonoTableInfo *tables = image->tables;
ICALL_EXPORT MonoBoolean
ves_icall_RuntimeTypeHandle_IsArray (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoBoolean res = !type->byref && (type->type == MONO_TYPE_ARRAY || type->type == MONO_TYPE_SZARRAY);
{
char *name;
- mono_error_init (error);
+ error_init (error);
if (klass->byval_arg.type != MONO_TYPE_TYPEDBYREF)
return;
name = mono_type_get_full_name (klass);
mono_error_set_type_load_name (error, name, g_strdup (""), "");
}
+
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeType_make_array_type (MonoReflectionTypeHandle ref_type, int rank, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
else
aklass = mono_bounded_array_class_get (klass, rank, TRUE);
+ if (mono_class_has_failure (aklass)) {
+ mono_error_set_for_class_failure (error, aklass);
+ return MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE);
+ }
+
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
return mono_type_get_object_handle (domain, &aklass->byval_arg, error);
}
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeType_make_byref_type (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeType_MakePointerType (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
{
MonoReflectionMethod *ret = NULL;
MonoError error;
- ret = mono_method_get_object_checked (mono_domain_get (), mono_object_get_virtual_method (delegate->target, delegate->method), mono_object_class (delegate->target), &error);
+ MonoMethod *m;
+
+ m = mono_object_get_virtual_method (delegate->target, delegate->method);
+ ret = mono_method_get_object_checked (mono_domain_get (), m, m->klass, &error);
mono_error_set_pending_exception (&error);
return ret;
}
ICALL_EXPORT MonoObjectHandle
ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObjectHandle this_obj, MonoStringHandle class_name, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (this_obj);
MonoRealProxyHandle rp = MONO_HANDLE_CAST (MonoRealProxy, this_obj);
ptr = buf;
while (size > initial_size) {
- size = (guint) GetLogicalDriveStrings (initial_size, ptr);
+ size = (guint) mono_w32file_get_logical_drive (initial_size, ptr);
if (size > initial_size) {
if (ptr != buf)
g_free (ptr);
MonoError error;
gunichar2 volume_name [MAX_PATH + 1];
- if (GetVolumeInformation (mono_string_chars (path), NULL, 0, NULL, NULL, NULL, volume_name, MAX_PATH + 1) == FALSE)
+ if (mono_w32file_get_volume_information (mono_string_chars (path), NULL, 0, NULL, NULL, NULL, volume_name, MAX_PATH + 1) == FALSE)
return NULL;
MonoString *result = mono_string_from_utf16_checked (volume_name, &error);
mono_error_set_pending_exception (&error);
gint32 *error)
{
gboolean result;
- ULARGE_INTEGER wapi_free_bytes_avail;
- ULARGE_INTEGER wapi_total_number_of_bytes;
- ULARGE_INTEGER wapi_total_number_of_free_bytes;
*error = ERROR_SUCCESS;
- result = GetDiskFreeSpaceEx (mono_string_chars (path_name), &wapi_free_bytes_avail, &wapi_total_number_of_bytes,
- &wapi_total_number_of_free_bytes);
- if (result) {
- *free_bytes_avail = wapi_free_bytes_avail.QuadPart;
- *total_number_of_bytes = wapi_total_number_of_bytes.QuadPart;
- *total_number_of_free_bytes = wapi_total_number_of_free_bytes.QuadPart;
- } else {
- *free_bytes_avail = 0;
- *total_number_of_bytes = 0;
- *total_number_of_free_bytes = 0;
- *error = GetLastError ();
- }
+ result = mono_w32file_get_disk_free_space (mono_string_chars (path_name), free_bytes_avail, total_number_of_bytes, total_number_of_free_bytes);
+ if (!result)
+ *error = mono_w32error_get_last ();
return result;
}
static inline guint32
mono_icall_drive_info_get_drive_type (MonoString *root_path_name)
{
- return GetDriveType (mono_string_chars (root_path_name));
+ return mono_w32file_get_drive_type (mono_string_chars (root_path_name));
}
#endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) */
ICALL_EXPORT gboolean
ves_icall_get_resources_ptr (MonoReflectionAssemblyHandle assembly, gpointer *result, gint32 *size, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoPEResourceDataEntry *entry;
MonoImage *image;
ICALL_EXPORT MonoObjectHandle
ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
return MONO_HANDLE_NEW (MonoObject, mono_object_new_checked (domain, klass, error));
}
-ICALL_EXPORT MonoReflectionMethod *
-ves_icall_MonoMethod_get_base_method (MonoReflectionMethod *m, gboolean definition)
-{
- MonoReflectionMethod *ret = NULL;
- MonoError error;
-
- MonoClass *klass, *parent;
- MonoGenericContext *generic_inst = NULL;
- MonoMethod *method = m->method;
- MonoMethod *result = NULL;
- int slot;
-
- if (method->klass == NULL)
- return m;
-
- if (!(method->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
- MONO_CLASS_IS_INTERFACE (method->klass) ||
- method->flags & METHOD_ATTRIBUTE_NEW_SLOT)
- return m;
-
- slot = mono_method_get_vtable_slot (method);
- if (slot == -1)
- return m;
-
- klass = method->klass;
- if (mono_class_is_ginst (klass)) {
- generic_inst = mono_class_get_context (klass);
- klass = mono_class_get_generic_class (klass)->container_class;
- }
-
-retry:
- if (definition) {
- /* At the end of the loop, klass points to the eldest class that has this virtual function slot. */
- for (parent = klass->parent; parent != NULL; parent = parent->parent) {
- /* on entry, klass is either a plain old non-generic class and generic_inst == NULL
- or klass is the generic container class and generic_inst is the instantiation.
-
- when we go to the parent, if the parent is an open constructed type, we need to
- replace the type parameters by the definitions from the generic_inst, and then take it
- apart again into the klass and the generic_inst.
-
- For cases like this:
- class C<T> : B<T, int> {
- public override void Foo () { ... }
- }
- class B<U,V> : A<HashMap<U,V>> {
- public override void Foo () { ... }
- }
- class A<X> {
- public virtual void Foo () { ... }
- }
-
- if at each iteration the parent isn't open, we can skip inflating it. if at some
- iteration the parent isn't generic (after possible inflation), we set generic_inst to
- NULL;
- */
- MonoGenericContext *parent_inst = NULL;
- if (mono_class_is_open_constructed_type (mono_class_get_type (parent))) {
- parent = mono_class_inflate_generic_class_checked (parent, generic_inst, &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return NULL;
- }
- }
- if (mono_class_is_ginst (parent)) {
- parent_inst = mono_class_get_context (parent);
- parent = mono_class_get_generic_class (parent)->container_class;
- }
-
- mono_class_setup_vtable (parent);
- if (parent->vtable_size <= slot)
- break;
- klass = parent;
- generic_inst = parent_inst;
- }
- } else {
- klass = klass->parent;
- if (!klass)
+ICALL_EXPORT MonoReflectionMethodHandle
+ves_icall_MonoMethod_get_base_method (MonoReflectionMethodHandle m, gboolean definition, MonoError *error)
+{
+ error_init (error);
+ MonoMethod *method = MONO_HANDLE_GETVAL (m, method);
+
+ MonoMethod *base = mono_method_get_base_method (method, definition, error);
+ return_val_if_nok (error, MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE));
+ if (base == method) {
+ /* we want to short-circuit and return 'm' here. But we should
+ return the same method object that
+ mono_method_get_object_handle, below would return. Since
+ that call takes NULL for the reftype argument, it will take
+ base->klass as the reflected type for the MonoMethod. So we
+ need to check that m also has base->klass as the reflected
+ type. */
+ MonoReflectionTypeHandle orig_reftype = MONO_HANDLE_NEW_GET (MonoReflectionType, m, reftype);
+ MonoClass *orig_klass = mono_class_from_mono_type (MONO_HANDLE_GETVAL (orig_reftype, type));
+ if (base->klass == orig_klass)
return m;
- if (mono_class_is_open_constructed_type (mono_class_get_type (klass))) {
- klass = mono_class_inflate_generic_class_checked (klass, generic_inst, &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return NULL;
- }
-
- generic_inst = NULL;
- }
- if (mono_class_is_ginst (klass)) {
- generic_inst = mono_class_get_context (klass);
- klass = mono_class_get_generic_class (klass)->container_class;
- }
-
- }
-
- if (generic_inst) {
- klass = mono_class_inflate_generic_class_checked (klass, generic_inst, &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return NULL;
- }
- }
-
- if (klass == method->klass)
- return m;
-
- /*This is possible if definition == FALSE.
- * Do it here to be really sure we don't read invalid memory.
- */
- if (slot >= klass->vtable_size)
- return m;
-
- mono_class_setup_vtable (klass);
-
- result = klass->vtable [slot];
- if (result == NULL) {
- /* It is an abstract method */
- gboolean found = FALSE;
- gpointer iter = NULL;
- while ((result = mono_class_get_methods (klass, &iter))) {
- if (result->slot == slot) {
- found = TRUE;
- break;
- }
- }
- /* found might be FALSE if we looked in an abstract class
- * that doesn't override an abstract method of its
- * parent:
- * abstract class Base {
- * public abstract void Foo ();
- * }
- * abstract class Derived : Base { }
- * class Child : Derived {
- * public override void Foo () { }
- * }
- *
- * if m was Child.Foo and we ask for the base method,
- * then we get here with klass == Derived and found == FALSE
- */
- /* but it shouldn't be the case that if we're looking
- * for the definition and didn't find a result; the
- * loop above should've taken us as far as we could
- * go! */
- g_assert (!(definition && !found));
- if (!found)
- goto retry;
}
-
- g_assert (result != NULL);
-
- ret = mono_method_get_object_checked (mono_domain_get (), result, NULL, &error);
- mono_error_set_pending_exception (&error);
- return ret;
+ return mono_method_get_object_handle (mono_domain_get (), base, NULL, error);
}
-ICALL_EXPORT MonoString*
-ves_icall_MonoMethod_get_name (MonoReflectionMethod *m)
+ICALL_EXPORT MonoStringHandle
+ves_icall_MonoMethod_get_name (MonoReflectionMethodHandle m, MonoError *error)
{
- MonoMethod *method = m->method;
+ error_init (error);
+ MonoMethod *method = MONO_HANDLE_GETVAL (m, method);
- MONO_OBJECT_SETREF (m, name, mono_string_new (mono_object_domain (m), method->name));
- return m->name;
+ MonoStringHandle s = mono_string_new_handle (MONO_HANDLE_DOMAIN (m), method->name, error);
+ if (!is_ok (error))
+ return NULL_HANDLE_STRING;
+ MONO_HANDLE_SET (m, name, s);
+ return s;
}
ICALL_EXPORT void
{
const char *exc_class, *exc_arg;
- mono_error_init (error);
+ error_init (error);
if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
return;
mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
add_modifier_to_array (MonoDomain *domain, MonoImage *image, MonoCustomMod *modifier, MonoArrayHandle dest, int dest_idx, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoClass *klass = mono_class_get_checked (image, modifier->token, error);
if (!is_ok (error))
goto leave;
int i, count = 0;
MonoDomain *domain = mono_domain_get ();
- mono_error_init (error);
+ error_init (error);
for (i = 0; i < type->num_mods; ++i) {
if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required))
count++;
ICALL_EXPORT MonoArrayHandle
ves_icall_ParameterInfo_GetTypeModifiers (MonoReflectionParameterHandle param, MonoBoolean optional, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoReflectionTypeHandle rt = MONO_HANDLE_NEW (MonoReflectionType, NULL);
MONO_HANDLE_GET (rt, param, ClassImpl);
MonoType *type = MONO_HANDLE_GETVAL (rt, type);
ICALL_EXPORT MonoArrayHandle
ves_icall_MonoPropertyInfo_GetTypeModifiers (MonoReflectionPropertyHandle property, MonoBoolean optional, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoProperty *prop = MONO_HANDLE_GETVAL (property, property);
MonoClass *klass = MONO_HANDLE_GETVAL (property, klass);
MonoType *type = get_property_type (prop);
char *info;
MonoStringHandle display_name;
- mono_error_init (error);
+ error_init (error);
info = mono_get_runtime_callbacks ()->get_runtime_build_info ();
display_name = mono_string_new_handle (mono_domain_get (), info, error);
g_free (info);
/**
* mono_add_internal_call:
- * @name: method specification to surface to the managed world
- * @method: pointer to a C method to invoke when the method is called
+ * \param name method specification to surface to the managed world
+ * \param method pointer to a C method to invoke when the method is called
*
- * This method surfaces the C function pointed by @method as a method
+ * This method surfaces the C function pointed by \p method as a method
* that has been surfaced in managed code with the method specified in
- * @name as an internal call.
+ * \p name as an internal call.
*
* Internal calls are surfaced to all app domains loaded and they are
* accessibly by a type with the specified name.
/**
* mono_lookup_internal_call_full:
- * @method: the method to look up
- * @uses_handles: out argument if method needs handles around managed objects.
- *
- * Returns a pointer to the icall code for the given method. If
- * uses_handles is not NULL, it will be set to TRUE if the method
+ * \param method the method to look up
+ * \param uses_handles out argument if method needs handles around managed objects.
+ * \returns a pointer to the icall code for the given method. If
+ * \p uses_handles is not NULL, it will be set to TRUE if the method
* needs managed objects wrapped using the infrastructure in handle.h
*
* If the method is not found, warns and returns NULL.
res = mono_metadata_signature_alloc (corlib, len - 1);
res->pinvoke = 1;
-#ifdef HOST_WIN32
+#ifdef TARGET_WIN32
/*
* Under windows, the default pinvoke calling convention is STDCALL but
* we need CDECL.
projects / mono.git / blobdiff