MonoReflectionAssembly*
mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly)
{
+ HANDLE_FUNCTION_ENTER ();
MonoError error;
- MonoReflectionAssembly *result;
- result = mono_assembly_get_object_checked (domain, assembly, &error);
+ MonoReflectionAssemblyHandle result = mono_assembly_get_object_handle (domain, assembly, &error);
mono_error_cleanup (&error); /* FIXME new API that doesn't swallow the error */
- return result;
+ HANDLE_FUNCTION_RETURN_OBJ (result);
+}
+
+static MonoReflectionAssemblyHandle
+assembly_object_construct (MonoDomain *domain, MonoClass *unused_klass, MonoAssembly *assembly, gpointer user_data, MonoError *error)
+{
+ mono_error_init (error);
+ MonoReflectionAssemblyHandle res = MONO_HANDLE_NEW (MonoReflectionAssembly, mono_object_new_checked (domain, mono_class_get_mono_assembly_class (), error));
+ return_val_if_nok (error, MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE));
+ MONO_HANDLE_SETVAL (res, assembly, MonoAssembly*, assembly);
+ return res;
+}
+
+/*
+ * mono_assembly_get_object_handle:
+ * @domain: an app domain
+ * @assembly: an assembly
+ *
+ * Return an System.Reflection.Assembly object representing the MonoAssembly @assembly.
+ */
+MonoReflectionAssemblyHandle
+mono_assembly_get_object_handle (MonoDomain *domain, MonoAssembly *assembly, MonoError *error)
+{
+ mono_error_init (error);
+ return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionAssemblyHandle, assembly, NULL, assembly_object_construct, NULL);
}
+
/*
- * mono_assembly_get_object_checked:
+ * mono_assembly_get_object_handle:
* @domain: an app domain
* @assembly: an assembly
*
MonoReflectionAssembly*
mono_assembly_get_object_checked (MonoDomain *domain, MonoAssembly *assembly, MonoError *error)
{
- MonoReflectionAssembly *res;
-
+ HANDLE_FUNCTION_ENTER ();
mono_error_init (error);
-
- CHECK_OBJECT (MonoReflectionAssembly *, assembly, NULL);
- res = (MonoReflectionAssembly *)mono_object_new_checked (domain, mono_class_get_mono_assembly_class (), error);
- if (!res)
- return NULL;
- res->assembly = assembly;
-
- CACHE_OBJECT (MonoReflectionAssembly *, assembly, res, NULL);
+ MonoReflectionAssemblyHandle result = mono_assembly_get_object_handle (domain, assembly, error);
+ HANDLE_FUNCTION_RETURN_OBJ (result);
}
MonoReflectionModule*
mono_module_get_object (MonoDomain *domain, MonoImage *image)
{
+ HANDLE_FUNCTION_ENTER ();
MonoError error;
- MonoReflectionModule *result;
- result = mono_module_get_object_checked (domain, image, &error);
+ MonoReflectionModuleHandle result = mono_module_get_object_handle (domain, image, &error);
mono_error_cleanup (&error);
- return result;
+ HANDLE_FUNCTION_RETURN_OBJ (result);
}
-MonoReflectionModule*
-mono_module_get_object_checked (MonoDomain *domain, MonoImage *image, MonoError *error)
+static MonoReflectionModuleHandle
+module_object_construct (MonoDomain *domain, MonoClass *unused_klass, MonoImage *image, gpointer user_data, MonoError *error)
{
- MonoReflectionModule *res;
char* basename;
mono_error_init (error);
- CHECK_OBJECT (MonoReflectionModule *, image, NULL);
- res = (MonoReflectionModule *)mono_object_new_checked (domain, mono_class_get_mono_module_class (), error);
- if (!res)
- return NULL;
+ MonoReflectionModuleHandle res = MONO_HANDLE_NEW (MonoReflectionModule, mono_object_new_checked (domain, mono_class_get_mono_module_class (), error));
+ if (!is_ok (error))
+ goto fail;
- res->image = image;
- MonoReflectionAssembly *assm_obj = mono_assembly_get_object_checked (domain, image->assembly, error);
- if (!assm_obj)
- return NULL;
- MONO_OBJECT_SETREF (res, assembly, assm_obj);
+ MONO_HANDLE_SETVAL (res, image, MonoImage *, image);
+ MonoReflectionAssemblyHandle assm_obj = mono_assembly_get_object_handle (domain, image->assembly, error);
+ if (!is_ok (error))
+ goto fail;
+ MONO_HANDLE_SET (res, assembly, assm_obj);
- MONO_OBJECT_SETREF (res, fqname, mono_string_new (domain, image->name));
+ MONO_HANDLE_SET (res, fqname, mono_string_new_handle (domain, image->name, error));
+ if (!is_ok (error))
+ goto fail;
basename = g_path_get_basename (image->name);
- MONO_OBJECT_SETREF (res, name, mono_string_new (domain, basename));
- MONO_OBJECT_SETREF (res, scopename, mono_string_new (domain, image->module_name));
-
+ MONO_HANDLE_SET (res, name, mono_string_new_handle (domain, basename, error));
+ if (!is_ok (error))
+ goto fail;
+ MONO_HANDLE_SET (res, scopename, mono_string_new_handle (domain, image->module_name, error));
+ if (!is_ok (error))
+ goto fail;
+
g_free (basename);
+ guint32 token = 0;
if (image->assembly->image == image) {
- res->token = mono_metadata_make_token (MONO_TABLE_MODULE, 1);
+ token = mono_metadata_make_token (MONO_TABLE_MODULE, 1);
} else {
int i;
- res->token = 0;
if (image->assembly->image->modules) {
for (i = 0; i < image->assembly->image->module_count; i++) {
if (image->assembly->image->modules [i] == image)
- res->token = mono_metadata_make_token (MONO_TABLE_MODULEREF, i + 1);
+ token = mono_metadata_make_token (MONO_TABLE_MODULEREF, i + 1);
}
- g_assert (res->token);
+ g_assert (token != 0);
}
}
+ MONO_HANDLE_SETVAL (res, token, guint32, token);
- CACHE_OBJECT (MonoReflectionModule *, image, res, NULL);
+ return res;
+fail:
+ return MONO_HANDLE_CAST (MonoReflectionModule, NULL_HANDLE);
+}
+
+MonoReflectionModuleHandle
+mono_module_get_object_handle (MonoDomain *domain, MonoImage *image, MonoError *error)
+{
+ mono_error_init (error);
+ return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionModuleHandle, image, NULL, module_object_construct, NULL);
}
MonoReflectionModule*
mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index)
{
+ HANDLE_FUNCTION_ENTER ();
MonoError error;
- MonoReflectionModule *result;
- result = mono_module_file_get_object_checked (domain, image, table_index, &error);
+ MonoReflectionModuleHandle result = mono_module_file_get_object_handle (domain, image, table_index, &error);
mono_error_cleanup (&error);
- return result;
+ HANDLE_FUNCTION_RETURN_OBJ (result);
}
-MonoReflectionModule*
-mono_module_file_get_object_checked (MonoDomain *domain, MonoImage *image, int table_index, MonoError *error)
+MonoReflectionModuleHandle
+mono_module_file_get_object_handle (MonoDomain *domain, MonoImage *image, int table_index, MonoError *error)
{
- MonoReflectionModule *res;
MonoTableInfo *table;
guint32 cols [MONO_FILE_SIZE];
const char *name;
mono_error_init (error);
- res = (MonoReflectionModule *)mono_object_new_checked (domain, mono_class_get_mono_module_class (), error);
- if (!res)
- return NULL;
+ MonoReflectionModuleHandle res = MONO_HANDLE_NEW (MonoReflectionModule, mono_object_new_checked (domain, mono_class_get_mono_module_class (), error));
+ if (!is_ok (error))
+ goto fail;
table = &image->tables [MONO_TABLE_FILE];
g_assert (table_index < table->rows);
mono_metadata_decode_row (table, table_index, cols, MONO_FILE_SIZE);
- res->image = NULL;
- MonoReflectionAssembly *assm_obj = mono_assembly_get_object_checked (domain, image->assembly, error);
- if (!assm_obj)
- return NULL;
- MONO_OBJECT_SETREF (res, assembly, assm_obj);
+ MONO_HANDLE_SETVAL (res, image, MonoImage*, NULL);
+ MonoReflectionAssemblyHandle assm_obj = mono_assembly_get_object_handle (domain, image->assembly, error);
+ if (!is_ok (error))
+ goto fail;
+ MONO_HANDLE_SET (res, assembly, assm_obj);
name = mono_metadata_string_heap (image, cols [MONO_FILE_NAME]);
/* Check whenever the row has a corresponding row in the moduleref table */
name_idx = mono_metadata_decode_row_col (table, i, MONO_MODULEREF_NAME);
val = mono_metadata_string_heap (image, name_idx);
if (strcmp (val, name) == 0)
- res->image = image->modules [i];
+ MONO_HANDLE_SETVAL (res, image, MonoImage*, image->modules [i]);
}
- MONO_OBJECT_SETREF (res, fqname, mono_string_new (domain, name));
- MONO_OBJECT_SETREF (res, name, mono_string_new (domain, name));
- MONO_OBJECT_SETREF (res, scopename, mono_string_new (domain, name));
- res->is_resource = cols [MONO_FILE_FLAGS] & FILE_CONTAINS_NO_METADATA;
- res->token = mono_metadata_make_token (MONO_TABLE_FILE, table_index + 1);
+ MONO_HANDLE_SET (res, fqname, mono_string_new_handle (domain, name, error));
+ if (!is_ok (error))
+ goto fail;
+ MONO_HANDLE_SET (res, name, mono_string_new_handle (domain, name, error));
+ if (!is_ok (error))
+ goto fail;
+ MONO_HANDLE_SET (res, scopename, mono_string_new_handle (domain, name, error));
+ if (!is_ok (error))
+ goto fail;
+ MONO_HANDLE_SETVAL (res, is_resource, MonoBoolean, cols [MONO_FILE_FLAGS] & FILE_CONTAINS_NO_METADATA);
+ MONO_HANDLE_SETVAL (res, token, guint32, mono_metadata_make_token (MONO_TABLE_FILE, table_index + 1));
return res;
+fail:
+ return MONO_HANDLE_CAST (MonoReflectionModule, NULL_HANDLE);
}
static MonoType*
mono_error_init (error);
+ g_assert (type != NULL);
klass = mono_class_from_mono_type (type);
/*we must avoid using @type as it might have come
return ret;
}
-/*
- * mono_method_get_object_checked:
- * @domain: an app domain
- * @method: a method
- * @refclass: the reflected type (can be NULL)
- * @error: set on error.
- *
- * Return an System.Reflection.MonoMethod object representing the method @method.
- * Returns NULL and sets @error on error.
- */
-MonoReflectionMethod*
-mono_method_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
+static MonoReflectionMethod*
+method_object_construct (MonoDomain *domain, MonoClass *refclass, MonoMethod *method, gpointer user_data, MonoError *error)
{
+ mono_error_init (error);
+ g_assert (refclass != NULL);
/*
* We use the same C representation for methods and constructors, but the type
* name in C# is different.
mono_error_init (error);
- if (!refclass)
- refclass = method->klass;
-
- CHECK_OBJECT (MonoReflectionMethod *, method, refclass);
if (*method->name == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0)) {
klass = mono_class_get_mono_cmethod_class ();
}
MONO_OBJECT_SETREF (ret, reftype, rt);
- CACHE_OBJECT (MonoReflectionMethod *, method, ret, refclass);
+ return ret;
leave:
g_assert (!mono_error_ok (error));
return NULL;
}
+/*
+ * mono_method_get_object_checked:
+ * @domain: an app domain
+ * @method: a method
+ * @refclass: the reflected type (can be NULL)
+ * @error: set on error.
+ *
+ * Return an System.Reflection.MonoMethod object representing the method @method.
+ * Returns NULL and sets @error on error.
+ */
+MonoReflectionMethod*
+mono_method_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
+{
+ mono_error_init (error);
+ if (!refclass)
+ refclass = method->klass;
+
+ return CHECK_OR_CONSTRUCT (MonoReflectionMethod*, method, refclass, method_object_construct, NULL);
+}
+
/*
* mono_method_clear_object:
*
return result;
}
-/*
- * mono_field_get_object_checked:
- * @domain: an app domain
- * @klass: a type
- * @field: a field
- * @error: set on error
- *
- * Return an System.Reflection.MonoField object representing the field @field
- * in class @klass. On error, returns NULL and sets @error.
- */
-MonoReflectionField*
-mono_field_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoClassField *field, MonoError *error)
+static MonoReflectionField*
+field_object_construct (MonoDomain *domain, MonoClass *klass, MonoClassField *field, gpointer user_data, MonoError *error)
{
MonoReflectionType *rt;
MonoReflectionField *res;
mono_error_init (error);
- CHECK_OBJECT (MonoReflectionField *, field, klass);
res = (MonoReflectionField *)mono_object_new_checked (domain, mono_class_get_mono_field_class (), error);
if (!res)
return NULL;
MONO_OBJECT_SETREF (res, type, rt);
}
res->attrs = mono_field_get_flags (field);
- CACHE_OBJECT (MonoReflectionField *, field, res, klass);
+ return res;
+}
+
+/*
+ * mono_field_get_object_checked:
+ * @domain: an app domain
+ * @klass: a type
+ * @field: a field
+ * @error: set on error
+ *
+ * Return an System.Reflection.MonoField object representing the field @field
+ * in class @klass. On error, returns NULL and sets @error.
+ */
+MonoReflectionField*
+mono_field_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoClassField *field, MonoError *error)
+{
+ mono_error_init (error);
+ return CHECK_OR_CONSTRUCT (MonoReflectionField*, field, klass, field_object_construct, NULL);
}
/*
return result;
}
+static MonoReflectionProperty*
+property_object_construct (MonoDomain *domain, MonoClass *klass, MonoProperty *property, gpointer user_data, MonoError *error)
+{
+ MonoReflectionProperty *res;
+
+ mono_error_init (error);
+
+ res = (MonoReflectionProperty *)mono_object_new_checked (domain, mono_class_get_mono_property_class (), error);
+ if (!res)
+ return NULL;
+ res->klass = klass;
+ res->property = property;
+ return res;
+}
+
/**
* mono_property_get_object:
* @domain: an app domain
MonoReflectionProperty*
mono_property_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoProperty *property, MonoError *error)
{
- MonoReflectionProperty *res;
-
mono_error_init (error);
-
- CHECK_OBJECT (MonoReflectionProperty *, property, klass);
- res = (MonoReflectionProperty *)mono_object_new_checked (domain, mono_class_get_mono_property_class (), error);
- if (!res)
- return NULL;
- res->klass = klass;
- res->property = property;
- CACHE_OBJECT (MonoReflectionProperty *, property, res, klass);
+ return CHECK_OR_CONSTRUCT (MonoReflectionProperty*, property, klass, property_object_construct, NULL);
}
/*
return result;
}
+static MonoReflectionEvent*
+event_object_construct (MonoDomain *domain, MonoClass *klass, MonoEvent *event, gpointer user_data, MonoError *error)
+{
+ MonoReflectionMonoEvent *mono_event;
+
+ mono_error_init (error);
+ mono_event = (MonoReflectionMonoEvent *)mono_object_new_checked (domain, mono_class_get_mono_event_class (), error);
+ if (!mono_event)
+ return NULL;
+ mono_event->klass = klass;
+ mono_event->event = event;
+ return &mono_event->object;
+}
+
/**
* mono_event_get_object_checked:
* @domain: an app domain
MonoReflectionEvent*
mono_event_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoEvent *event, MonoError *error)
{
- MonoReflectionEvent *res;
- MonoReflectionMonoEvent *mono_event;
-
mono_error_init (error);
- CHECK_OBJECT (MonoReflectionEvent *, event, klass);
- mono_event = (MonoReflectionMonoEvent *)mono_object_new_checked (domain, mono_class_get_mono_event_class (), error);
- if (!mono_event)
- return NULL;
- mono_event->klass = klass;
- mono_event->event = event;
- res = (MonoReflectionEvent*)mono_event;
- CACHE_OBJECT (MonoReflectionEvent *, event, res, klass);
+ return CHECK_OR_CONSTRUCT (MonoReflectionEvent*, event, klass, event_object_construct, NULL);
}
/**
return *reflection_missing;
}
-/*
- * mono_param_get_objects:
- * @domain: an app domain
- * @method: a method
- *
- * Return an System.Reflection.ParameterInfo array object representing the parameters
- * in the method @method.
- */
-MonoArray*
-mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
+static MonoArray*
+param_objects_construct (MonoDomain *domain, MonoClass *refclass, MonoMethodSignature **addr_of_sig, gpointer user_data, MonoError *error)
{
static MonoClass *System_Reflection_ParameterInfo;
static MonoClass *System_Reflection_ParameterInfo_array;
+
+ MonoMethod *method = (MonoMethod*)user_data;
+ MonoMethodSignature *sig = *addr_of_sig; /* see note in mono_param_get_objects_internal */
+
MonoArray *res = NULL;
MonoReflectionMethod *member = NULL;
MonoReflectionParameter *param = NULL;
MonoObject *dbnull = NULL;
MonoObject *missing = NULL;
MonoMarshalSpec **mspecs = NULL;
- MonoMethodSignature *sig = NULL;
MonoVTable *pinfo_vtable;
MonoReflectionType *rt;
int i;
if (!System_Reflection_ParameterInfo_array) {
MonoClass *klass;
-
klass = mono_class_get_mono_parameter_info_class ();
-
- mono_memory_barrier ();
System_Reflection_ParameterInfo = klass;
-
-
klass = mono_array_class_get (klass, 1);
- mono_memory_barrier ();
System_Reflection_ParameterInfo_array = klass;
}
- sig = mono_method_signature_checked (method, error);
- if (!mono_error_ok (error))
- goto leave;
-
- if (!sig->param_count) {
- res = mono_array_new_specific_checked (mono_class_vtable (domain, System_Reflection_ParameterInfo_array), 0, error);
- if (!res)
- goto leave;
-
- return res;
- }
-
- /* Note: the cache is based on the address of the signature into the method
- * since we already cache MethodInfos with the method as keys.
- */
- CHECK_OBJECT (MonoArray*, &(method->signature), refclass);
-
member = mono_method_get_object_checked (domain, method, refclass, error);
if (!member)
goto leave;
if (!is_ok (error))
return NULL;
- CACHE_OBJECT (MonoArray *, &(method->signature), res, refclass);
+ return res;
+}
+
+/*
+ * mono_param_get_objects:
+ * @domain: an app domain
+ * @method: a method
+ *
+ * Return an System.Reflection.ParameterInfo array object representing the parameters
+ * in the method @method.
+ */
+MonoArray*
+mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
+{
+ mono_error_init (error);
+
+ MonoMethodSignature *sig = mono_method_signature_checked (method, error);
+ if (!mono_error_ok (error))
+ goto leave;
+
+ if (!sig->param_count) {
+ MonoArray *res = mono_array_new_checked (domain, mono_class_get_mono_parameter_info_class (), 0, error);
+ if (!res)
+ goto leave;
+
+ return res;
+ }
+
+ /* Note: the cache is based on the address of the signature into the method
+ * since we already cache MethodInfos with the method as keys.
+ */
+ return CHECK_OR_CONSTRUCT (MonoArray*, &method->signature, refclass, param_objects_construct, method);
+leave:
+ return NULL;
}
MonoArray*
return result;
}
-/**
- * mono_method_body_get_object_checked:
- * @domain: an app domain
- * @method: a method
- * @error: set on error
- *
- * Return an System.Reflection.MethodBody object representing the
- * method @method. On failure, returns NULL and sets @error.
- */
-MonoReflectionMethodBody*
-mono_method_body_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoError *error)
+static MonoReflectionMethodBody*
+method_body_object_construct (MonoDomain *domain, MonoClass *unused_class, MonoMethod *method, gpointer user_data, MonoError *error)
{
MonoReflectionMethodBody *ret;
MonoMethodHeader *header;
return NULL;
}
- CHECK_OBJECT (MonoReflectionMethodBody *, method, NULL);
-
if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
(method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
}
mono_metadata_free_mh (header);
- CACHE_OBJECT (MonoReflectionMethodBody *, method, ret, NULL);
return ret;
-
fail:
mono_metadata_free_mh (header);
return NULL;
}
+/**
+ * mono_method_body_get_object_checked:
+ * @domain: an app domain
+ * @method: a method
+ * @error: set on error
+ *
+ * Return an System.Reflection.MethodBody object representing the
+ * method @method. On failure, returns NULL and sets @error.
+ */
+MonoReflectionMethodBody*
+mono_method_body_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoError *error)
+{
+ mono_error_init (error);
+ return CHECK_OR_CONSTRUCT (MonoReflectionMethodBody *, method, NULL, method_body_object_construct, NULL);
+}
+
/**
* mono_get_dbnull_object:
* @domain: Domain where the object lives
projects / mono.git / blobdiff