-/*
- * sre.c: Routines for creating an image at runtime
- * and related System.Reflection.Emit icalls
+/**
+ * \file
+ * Routines for creating an image at runtime
+ * and related System.Reflection.Emit icalls
*
*
* Author:
#include "mono/metadata/tokentype.h"
#include "mono/utils/checked-build.h"
#include "mono/utils/mono-digest.h"
-#include "mono/io-layer/io-layer.h"
+#include "mono/utils/w32api.h"
-static GENERATE_GET_CLASS_WITH_CACHE (marshal_as_attribute, System.Runtime.InteropServices, MarshalAsAttribute);
-static GENERATE_GET_CLASS_WITH_CACHE (module_builder, System.Reflection.Emit, ModuleBuilder);
+static GENERATE_GET_CLASS_WITH_CACHE (marshal_as_attribute, "System.Runtime.InteropServices", "MarshalAsAttribute");
+static GENERATE_GET_CLASS_WITH_CACHE (module_builder, "System.Reflection.Emit", "ModuleBuilder");
static char* string_to_utf8_image_raw (MonoImage *image, MonoString *s, MonoError *error);
/* FIXME all callers to string_to_utf8_image_raw should use handles */
HANDLE_FUNCTION_ENTER ();
char* result = NULL;
- mono_error_init (error);
+ error_init (error);
MONO_HANDLE_DCL (MonoString, s);
result = mono_string_to_utf8_image (image, s, error);
HANDLE_FUNCTION_RETURN_VAL (result);
{
MONO_REQ_GC_UNSAFE_MODE;
- mono_error_init (error);
+ error_init (error);
MonoExceptionClause *clauses;
MonoExceptionClause *clause;
{
MONO_REQ_GC_UNSAFE_MODE;
- mono_error_init (error);
+ error_init (error);
memset (rmb, 0, sizeof (ReflectionMethodBuilder));
rmb->ilgen = mb->ilgen;
const char *name = mb->attrs & METHOD_ATTRIBUTE_STATIC ? ".cctor": ".ctor";
- mono_error_init (error);
+ error_init (error);
memset (rmb, 0, sizeof (ReflectionMethodBuilder));
MonoDynamicTable *table;
guint32 *values;
- mono_error_init (error);
+ error_init (error);
table = &assembly->tables [MONO_TABLE_STANDALONESIG];
idx = table->next_idx ++;
MonoMethodSignature *sig = NULL;
char *name = NULL;
- mono_error_init (error);
+ error_init (error);
MonoArrayHandle parameters = MONO_HANDLE_NEW_GET (MonoArray, m, parameters);
guint32 nparams = mono_array_handle_length (parameters);
{
guint32 token = 0;
- mono_error_init (error);
+ error_init (error);
MonoClass *klass = mono_handle_class (obj);
if (strcmp (klass->name, "MonoMethod") == 0 || strcmp (klass->name, "MonoCMethod") == 0) {
{
guint32 token = 0;
- mono_error_init (error);
+ error_init (error);
MonoClass *klass = mono_handle_class (obj);
static gboolean
image_module_basic_init (MonoReflectionModuleBuilderHandle moduleb, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (moduleb);
MonoDynamicImage *image = MONO_HANDLE_GETVAL (moduleb, dynamic_image);
MonoReflectionAssemblyBuilderHandle ab = MONO_HANDLE_NEW (MonoReflectionAssemblyBuilder, NULL);
static gboolean
mono_image_module_basic_init (MonoReflectionModuleBuilderHandle moduleb, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return image_module_basic_init (moduleb, error);
}
mono_type_array_get_and_resolve (MonoArrayHandle array, int idx, MonoError *error)
{
HANDLE_FUNCTION_ENTER();
- mono_error_init (error);
+ error_init (error);
MonoReflectionTypeHandle t = MONO_HANDLE_NEW (MonoReflectionType, NULL);
MONO_HANDLE_ARRAY_GETREF (t, array, idx);
MonoType *result = mono_reflection_type_handle_mono_type (t, error);
static MonoMethod *method_get_underlying_system_type = NULL;
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
if (!method_get_underlying_system_type)
method_get_underlying_system_type = mono_class_get_method_from_name (mono_defaults.systemtype_class, "get_UnderlyingSystemType", 0);
mono_reflection_type_get_handle (MonoReflectionType* ref_raw, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MONO_HANDLE_DCL (MonoReflectionType, ref);
MonoType *result = mono_reflection_type_handle_mono_type (ref, error);
HANDLE_FUNCTION_RETURN_VAL (result);
reflection_param_handle_mono_type (MonoReflectionGenericParamHandle ref_gparam, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoType *result = NULL;
mono_type_array_get_and_resolve_raw (MonoArray* array_raw, int idx, MonoError *error)
{
HANDLE_FUNCTION_ENTER(); /* FIXME callers of mono_type_array_get_and_resolve_raw should use handles */
- mono_error_init (error);
+ error_init (error);
MONO_HANDLE_DCL (MonoArray, array);
MonoType *result = mono_type_array_get_and_resolve (array, idx, error);
HANDLE_FUNCTION_RETURN_VAL (result);
mono_reflection_type_handle_mono_type (MonoReflectionTypeHandle ref, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoType* result = NULL;
MonoMethodSignature *sig;
int count, i;
- mono_error_init (error);
+ error_init (error);
count = MONO_HANDLE_IS_NULL (parameters) ? 0 : mono_array_handle_length (parameters);
ctor_builder_to_signature (MonoImage *image, MonoReflectionCtorBuilderHandle ctor, MonoError *error) {
MonoMethodSignature *sig;
- mono_error_init (error);
+ error_init (error);
sig = parameters_to_signature (image, MONO_HANDLE_NEW_GET (MonoArray, ctor, parameters), error);
return_val_if_nok (error, NULL);
method_builder_to_signature (MonoImage *image, MonoReflectionMethodBuilderHandle method, MonoError *error) {
MonoMethodSignature *sig;
- mono_error_init (error);
+ error_init (error);
sig = parameters_to_signature (image, MONO_HANDLE_NEW_GET(MonoArray, method, parameters), error);
return_val_if_nok (error, NULL);
HANDLE_FUNCTION_ENTER ();
MonoMethodSignature *sig = NULL;
- mono_error_init (error);
+ error_init (error);
sig = parameters_to_signature (NULL, MONO_HANDLE_NEW_GET (MonoArray, method, parameters), error);
if (!is_ok (error))
static void
get_prop_name_and_type (MonoObject *prop, char **name, MonoType **type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClass *klass = mono_object_class (prop);
if (strcmp (klass->name, "PropertyBuilder") == 0) {
MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *)prop;
static void
get_field_name_and_type (MonoObject *field, char **name, MonoType **type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClass *klass = mono_object_class (field);
if (strcmp (klass->name, "FieldBuilder") == 0) {
MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)field;
{
MonoTypeEnum simple_type;
- mono_error_init (error);
+ error_init (error);
if ((p-buffer) + 10 >= *buflen) {
char *newbuf;
*buflen *= 2;
{
int len;
- mono_error_init (error);
+ error_init (error);
/* Preallocate a large enough buffer */
if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype) {
/**
* mono_reflection_get_custom_attrs_blob:
- * @ctor: custom attribute constructor
- * @ctorArgs: arguments o the constructor
- * @properties:
- * @propValues:
- * @fields:
- * @fieldValues:
- *
+ * \param ctor custom attribute constructor
+ * \param ctorArgs arguments o the constructor
+ * \param properties
+ * \param propValues
+ * \param fields
+ * \param fieldValues
* Creates the blob of data that needs to be saved in the metadata and that represents
- * the custom attributed described by @ctor, @ctorArgs etc.
- * Returns: a Byte array representing the blob of data.
+ * the custom attributed described by \p ctor, \p ctorArgs etc.
+ * \returns a \c Byte array representing the blob of data.
*/
MonoArray*
mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues)
/**
* mono_reflection_get_custom_attrs_blob_checked:
- * @ctor: custom attribute constructor
- * @ctorArgs: arguments o the constructor
- * @properties:
- * @propValues:
- * @fields:
- * @fieldValues:
- * @error: set on error
- *
+ * \param ctor custom attribute constructor
+ * \param ctorArgs arguments o the constructor
+ * \param properties
+ * \param propValues
+ * \param fields
+ * \param fieldValues
+ * \param error set on error
* Creates the blob of data that needs to be saved in the metadata and that represents
- * the custom attributed described by @ctor, @ctorArgs etc.
- * Returns: a Byte array representing the blob of data. On failure returns NULL and sets @error.
+ * the custom attributed described by \p ctor, \p ctorArgs etc.
+ * \returns a \c Byte array representing the blob of data. On failure returns NULL and sets \p error.
*/
MonoArray*
mono_reflection_get_custom_attrs_blob_checked (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues, MonoError *error)
char *buffer, *p;
guint32 buflen, i;
- mono_error_init (error);
+ error_init (error);
if (strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
/* sig is freed later so allocate it in the heap */
reflection_setup_internal_class (MonoReflectionTypeBuilderHandle ref_tb, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
mono_loader_lock ();
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
reflection_setup_internal_class (ref_tb, error);
if (!is_ok (error))
{
MonoMarshalSpec *res;
- mono_error_init (error);
+ error_init (error);
res = image_g_new0 (image, MonoMarshalSpec, 1);
res->native = (MonoMarshalNative)minfo->type;
mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass,
MonoMarshalSpec *spec, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoReflectionMarshalAsAttributeHandle minfo = MONO_HANDLE_NEW (MonoReflectionMarshalAsAttribute, mono_object_new_checked (domain, mono_class_get_marshal_as_attribute_class (), error));
if (!is_ok (error))
gboolean dynamic;
int i;
- mono_error_init (error);
+ error_init (error);
/*
* Methods created using a MethodBuilder should have their memory allocated
* inside the image mempool, while dynamic methods should have their memory
ReflectionMethodBuilder rmb;
MonoMethodSignature *sig;
- mono_error_init (error);
+ error_init (error);
mono_loader_lock ();
methodbuilder_to_mono_method_raw (MonoClass *klass, MonoReflectionMethodBuilder* mb_raw, MonoError *error)
{
HANDLE_FUNCTION_ENTER (); /* FIXME change callers of methodbuilder_to_mono_method_raw to use handles */
- mono_error_init (error);
+ error_init (error);
MONO_HANDLE_DCL (MonoReflectionMethodBuilder, mb);
MonoMethod *result = methodbuilder_to_mono_method (klass, mb, error);
HANDLE_FUNCTION_RETURN_VAL (result);
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
int i;
- mono_error_init (error);
+ error_init (error);
if (klass->wastypebuilder)
return TRUE;
{
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
- mono_error_init (error);
+ error_init (error);
if (!ensure_runtime_vtable (gklass, error))
return FALSE;
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info_raw (klass); /* FIXME use handles */
int i, num, j;
- mono_error_init (error);
+ error_init (error);
if (!image_is_dynamic (klass->image) || (!tb && !mono_class_is_ginst (klass)) || klass->wastypebuilder)
return TRUE;
static MonoMethod*
mono_reflection_method_get_handle (MonoObject *method, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClass *klass = mono_object_class (method);
if (is_sr_mono_method (klass)) {
MonoReflectionMethod *sr_method = (MonoReflectionMethod*)method;
int i, j, onum;
MonoReflectionMethod *m;
- mono_error_init (error);
+ error_init (error);
*overrides = NULL;
*num_overrides = 0;
int fcount = tb->num_fields;
mono_class_set_field_count (klass, fcount);
- mono_error_init (error);
+ error_init (error);
if (tb->class_size) {
packing_size = tb->packing_size;
MonoClassPropertyInfo *info;
int i;
- mono_error_init (error);
+ error_init (error);
info = mono_class_get_property_info (klass);
if (!info) {
MonoClassEventInfo *info;
int i;
- mono_error_init (error);
+ error_init (error);
info = mono_class_alloc0 (klass, sizeof (MonoClassEventInfo));
mono_class_set_event_info (klass, info);
MonoReflectionTypeHandle
ves_icall_TypeBuilder_create_runtime_class (MonoReflectionTypeBuilderHandle ref_tb, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
reflection_create_generic_class (ref_tb, error);
mono_error_assert_ok (error);
GSList *l;
int i;
- mono_error_init (error);
+ error_init (error);
if (mono_runtime_is_shutting_down ()) {
mono_error_set_generic_error (error, "System", "InvalidOperationException", "");
MonoMethodSignature *sig;
g_assert (image_is_dynamic (image));
- mono_error_init (error);
+ error_init (error);
sig = (MonoMethodSignature *)g_hash_table_lookup (((MonoDynamicImage*)image)->vararg_aux_hash, GUINT_TO_POINTER (token));
if (sig)
static void
ensure_complete_type (MonoClass *klass, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (image_is_dynamic (klass->image) && !klass->wastypebuilder && mono_class_has_ref_info (klass)) {
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info_raw (klass); /* FIXME use handles */
MonoClass *oklass = obj->vtable->klass;
gpointer result = NULL;
- mono_error_init (error);
+ error_init (error);
if (strcmp (oklass->name, "String") == 0) {
result = mono_string_intern_checked ((MonoString*)obj, error);
void
mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
*overrides = NULL;
*num_overrides = 0;
}
void
ves_icall_DynamicMethod_create_dynamic_method (MonoReflectionDynamicMethodHandle mb, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
}
MonoType*
mono_reflection_type_get_handle (MonoReflectionType* ref, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (!ref)
return NULL;
return ref->type;
MonoType*
mono_reflection_type_handle_mono_type (MonoReflectionTypeHandle ref, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (MONO_HANDLE_IS_NULL (ref))
return NULL;
return MONO_HANDLE_GETVAL (ref, type);
gint32
ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilderHandle mb, MonoObjectHandle obj, gboolean create_open_instance, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (MONO_HANDLE_IS_NULL (obj)) {
mono_error_set_argument_null (error, "obj", "");
return 0;
MonoArrayHandle opt_param_types,
MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (MONO_HANDLE_IS_NULL (method)) {
mono_error_set_argument_null (error, "method", "");
return 0;
void
ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilderHandle mb, MonoObjectHandle obj, guint32 token, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
mono_dynamic_image_register_token (MONO_HANDLE_GETVAL (mb, dynamic_image), token, obj);
}
void
ves_icall_ModuleBuilder_basic_init (MonoReflectionModuleBuilderHandle moduleb, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
mono_image_module_basic_init (moduleb, error);
}