mono_domain_set_internal (domain);
- MONO_OBJECT_SETREF (copy, application_base, mono_marshal_xdomain_copy_value ((MonoObject*)setup->application_base));
- MONO_OBJECT_SETREF (copy, application_name, mono_marshal_xdomain_copy_value ((MonoObject*)setup->application_name));
- MONO_OBJECT_SETREF (copy, cache_path, mono_marshal_xdomain_copy_value ((MonoObject*)setup->cache_path));
- MONO_OBJECT_SETREF (copy, configuration_file, mono_marshal_xdomain_copy_value ((MonoObject*)setup->configuration_file));
- MONO_OBJECT_SETREF (copy, dynamic_base, mono_marshal_xdomain_copy_value ((MonoObject*)setup->dynamic_base));
- MONO_OBJECT_SETREF (copy, license_file, mono_marshal_xdomain_copy_value ((MonoObject*)setup->license_file));
- MONO_OBJECT_SETREF (copy, private_bin_path, mono_marshal_xdomain_copy_value ((MonoObject*)setup->private_bin_path));
- MONO_OBJECT_SETREF (copy, private_bin_path_probe, mono_marshal_xdomain_copy_value ((MonoObject*)setup->private_bin_path_probe));
- MONO_OBJECT_SETREF (copy, shadow_copy_directories, mono_marshal_xdomain_copy_value ((MonoObject*)setup->shadow_copy_directories));
- MONO_OBJECT_SETREF (copy, shadow_copy_files, mono_marshal_xdomain_copy_value ((MonoObject*)setup->shadow_copy_files));
+#define XCOPY_FIELD(dst,field,src,error) \
+ do { \
+ MonoObject *copied_val = mono_marshal_xdomain_copy_value ((MonoObject*)(src), error); \
+ return_val_if_nok (error, NULL); \
+ MONO_OBJECT_SETREF ((dst),field,copied_val); \
+ } while (0)
+
+ XCOPY_FIELD (copy, application_base, setup->application_base, error);
+ XCOPY_FIELD (copy, application_name, setup->application_name, error);
+ XCOPY_FIELD (copy, cache_path, setup->cache_path, error);
+ XCOPY_FIELD (copy, configuration_file, setup->configuration_file, error);
+ XCOPY_FIELD (copy, dynamic_base, setup->dynamic_base, error);
+ XCOPY_FIELD (copy, license_file, setup->license_file, error);
+ XCOPY_FIELD (copy, private_bin_path, setup->private_bin_path, error);
+ XCOPY_FIELD (copy, private_bin_path_probe, setup->private_bin_path_probe, error);
+ XCOPY_FIELD (copy, shadow_copy_directories, setup->shadow_copy_directories, error);
+ XCOPY_FIELD (copy, shadow_copy_files, setup->shadow_copy_files, error);
copy->publisher_policy = setup->publisher_policy;
copy->path_changed = setup->path_changed;
copy->loader_optimization = setup->loader_optimization;
copy->disallow_binding_redirects = setup->disallow_binding_redirects;
copy->disallow_code_downloads = setup->disallow_code_downloads;
- MONO_OBJECT_SETREF (copy, domain_initializer_args, mono_marshal_xdomain_copy_value ((MonoObject*)setup->domain_initializer_args));
+ XCOPY_FIELD (copy, domain_initializer_args, setup->domain_initializer_args, error);
copy->disallow_appbase_probe = setup->disallow_appbase_probe;
- MONO_OBJECT_SETREF (copy, application_trust, mono_marshal_xdomain_copy_value ((MonoObject*)setup->application_trust));
- MONO_OBJECT_SETREF (copy, configuration_bytes, mono_marshal_xdomain_copy_value ((MonoObject*)setup->configuration_bytes));
- MONO_OBJECT_SETREF (copy, serialized_non_primitives, mono_marshal_xdomain_copy_value ((MonoObject*)setup->serialized_non_primitives));
+ XCOPY_FIELD (copy, application_trust, setup->application_trust, error);
+ XCOPY_FIELD (copy, configuration_bytes, setup->configuration_bytes, error);
+ XCOPY_FIELD (copy, serialized_non_primitives, setup->serialized_non_primitives, error);
+#undef COPY_FIELD
+
mono_domain_set_internal (caller_domain);
return copy;
/* FIXME: What to do if the index points into the middle of a string ? */
- return mono_ldstr (mono_domain_get (), image, index);
+ MonoString *result = mono_ldstr_checked (mono_domain_get (), image, index, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoClassField*
func = mono_create_ftnptr (mono_domain_get (), trampoline);
}
- mono_delegate_ctor_with_method (delegate, target, func, method);
-
+ mono_delegate_ctor_with_method (delegate, target, func, method, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
return delegate;
}
MonoReflectionMethod *method,
MonoArray *out_args)
{
- mono_message_init (mono_object_domain (this_obj), this_obj, method, out_args);
+ MonoError error;
+ mono_message_init (mono_object_domain (this_obj), this_obj, method, out_args, &error);
+ mono_error_set_pending_exception (&error);
}
#ifndef DISABLE_REMOTING
gpointer compiled_ptr = mono_compile_method_checked (wrapper, &error);
if (mono_error_set_pending_exception (&error))
return NULL;
- mono_delegate_ctor_with_method ((MonoObject*)d, this_obj, compiled_ptr, wrapper);
+ mono_delegate_ctor_with_method ((MonoObject*)d, this_obj, compiled_ptr, wrapper, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
}
if (d->object.vtable->domain != mono_domain_get ()) {
MonoArray *out_args;
method = delegate->method;
- msg = mono_method_call_message_new (mono_marshal_method_from_wrapper (method), params, NULL, &async_callback, &state);
- ares = mono_async_result_new (mono_domain_get (), NULL, state, NULL, NULL);
+ msg = mono_method_call_message_new (mono_marshal_method_from_wrapper (method), params, NULL, &async_callback, &state, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ ares = mono_async_result_new (mono_domain_get (), NULL, state, NULL, NULL, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
MONO_OBJECT_SETREF (ares, async_delegate, (MonoObject *)delegate);
MONO_OBJECT_SETREF (ares, async_callback, (MonoObject *)async_callback);
MONO_OBJECT_SETREF (msg, async_result, ares);
sig = mono_signature_no_pinvoke (method);
- msg = mono_method_call_message_new (method, params, NULL, NULL, NULL);
+ msg = mono_method_call_message_new (method, params, NULL, NULL, NULL, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
ares = (MonoAsyncResult *)mono_array_get (msg->args, gpointer, sig->param_count - 1);
if (ares == NULL) {
mono_error_set_pending_exception (&error);
return NULL;
}
- mono_message_init (domain, msg, delegate->method_info, NULL);
+ mono_message_init (domain, msg, delegate->method_info, NULL, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
msg->call_type = CallType_EndInvoke;
MONO_OBJECT_SETREF (msg, async_result, ares);
res = mono_remoting_invoke ((MonoObject *)tp->rp, msg, &exc, &out_args, &error);
mono_marshal_use_aot_wrappers (gboolean use);
MonoObject *
-mono_marshal_xdomain_copy_value (MonoObject *val);
+mono_marshal_xdomain_copy_value (MonoObject *val, MonoError *error);
+
+MonoObject *
+ves_icall_mono_marshal_xdomain_copy_value (MonoObject *val);
int
mono_mb_emit_save_args (MonoMethodBuilder *mb, MonoMethodSignature *sig, gboolean save_this);
MonoAsyncResult *
mono_async_result_new (MonoDomain *domain, HANDLE handle,
- MonoObject *state, gpointer data, MonoObject *object_data);
+ MonoObject *state, gpointer data, MonoObject *object_data, MonoError *error);
MonoObject *
ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *ares);
HANDLE
mono_wait_handle_get_handle (MonoWaitHandle *handle);
-void
+gboolean
mono_message_init (MonoDomain *domain, MonoMethodMessage *this_obj,
- MonoReflectionMethod *method, MonoArray *out_args);
+ MonoReflectionMethod *method, MonoArray *out_args, MonoError *error);
MonoObject *
mono_message_invoke (MonoObject *target, MonoMethodMessage *msg,
MonoMethodMessage *
mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
- MonoDelegate **cb, MonoObject **state);
+ MonoDelegate **cb, MonoObject **state, MonoError *error);
void
mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args, MonoError *error);
-void
-mono_delegate_ctor_with_method (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoMethod *method);
+gboolean
+mono_delegate_ctor_with_method (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoMethod *method, MonoError *error);
-void
-mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr);
+gboolean
+mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoError *error);
void*
mono_class_get_allocation_ftn (MonoVTable *vtable, gboolean for_box, gboolean *pass_size_in_words);
MonoString *
mono_string_new_size_checked (MonoDomain *domain, gint32 len, MonoError *error);
+MonoString*
+mono_ldstr_checked (MonoDomain *domain, MonoImage *image, uint32_t str_index, MonoError *error);
+
MonoString*
mono_string_new_len_checked (MonoDomain *domain, const char *text, guint length, MonoError *error);
MonoString*
mono_ldstr (MonoDomain *domain, MonoImage *image, guint32 idx)
{
- MONO_REQ_GC_UNSAFE_MODE;
MonoError error;
+ MonoString *result = mono_ldstr_checked (domain, image, idx, &error);
+ mono_error_cleanup (&error);
+ return result;
+}
+
+/**
+ * mono_ldstr_checked:
+ * @domain: the domain where the string will be used.
+ * @image: a metadata context
+ * @idx: index into the user string table.
+ * @error: set on error.
+ *
+ * Implementation for the ldstr opcode.
+ * Returns: a loaded string from the @image/@idx combination.
+ * On failure returns NULL and sets @error.
+ */
+MonoString*
+mono_ldstr_checked (MonoDomain *domain, MonoImage *image, guint32 idx, MonoError *error)
+{
+ MONO_REQ_GC_UNSAFE_MODE;
+ mono_error_init (error);
if (image->dynamic) {
- MonoString *str = (MonoString *)mono_lookup_dynamic_token (image, MONO_TOKEN_STRING | idx, NULL, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ MonoString *str = (MonoString *)mono_lookup_dynamic_token (image, MONO_TOKEN_STRING | idx, NULL, error);
return str;
} else {
if (!mono_verifier_verify_string_signature (image, idx, NULL))
return NULL; /*FIXME we should probably be raising an exception here*/
- MonoString *str = mono_ldstr_metadata_sig (domain, mono_metadata_user_string (image, idx), &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ MonoString *str = mono_ldstr_metadata_sig (domain, mono_metadata_user_string (image, idx), error);
return str;
}
}
* @handle: wait handle.
* @state: state to pass to AsyncResult
* @data: C closure data.
+ * @error: set on error.
*
* Creates a new MonoAsyncResult (AsyncResult C# class) in the given domain.
* If the handle is not null, the handle is initialized to a MonOWaitHandle.
+ * On failure returns NULL and sets @error.
*
*/
MonoAsyncResult *
-mono_async_result_new (MonoDomain *domain, HANDLE handle, MonoObject *state, gpointer data, MonoObject *object_data)
+mono_async_result_new (MonoDomain *domain, HANDLE handle, MonoObject *state, gpointer data, MonoObject *object_data, MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
- MonoError error;
- MonoAsyncResult *res = (MonoAsyncResult *)mono_object_new_checked (domain, mono_defaults.asyncresult_class, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
- MonoObject *context = mono_runtime_capture_context (domain, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ mono_error_init (error);
+ MonoAsyncResult *res = (MonoAsyncResult *)mono_object_new_checked (domain, mono_defaults.asyncresult_class, error);
+ return_val_if_nok (error, NULL);
+ MonoObject *context = mono_runtime_capture_context (domain, error);
+ return_val_if_nok (error, NULL);
/* we must capture the execution context from the original thread */
if (context) {
MONO_OBJECT_SETREF (res, execution_context, context);
res->data = (void **)data;
MONO_OBJECT_SETREF (res, object_data, object_data);
MONO_OBJECT_SETREF (res, async_state, state);
- MonoWaitHandle *wait_handle = mono_wait_handle_new (domain, handle, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ MonoWaitHandle *wait_handle = mono_wait_handle_new (domain, handle, error);
+ return_val_if_nok (error, NULL);
if (handle != NULL)
MONO_OBJECT_SETREF (res, handle, (MonoObject *) wait_handle);
return res;
}
-void
+gboolean
mono_message_init (MonoDomain *domain,
MonoMethodMessage *this_obj,
MonoReflectionMethod *method,
- MonoArray *out_args)
+ MonoArray *out_args,
+ MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
static MonoClass *object_array_klass;
static MonoClass *byte_array_klass;
static MonoClass *string_array_klass;
- MonoError error;
+ mono_error_init (error);
MonoMethodSignature *sig = mono_method_signature (method->method);
MonoString *name;
MonoArray *arr;
MONO_OBJECT_SETREF (this_obj, method, method);
- arr = mono_array_new_specific_checked (mono_class_vtable (domain, object_array_klass), sig->param_count, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ arr = mono_array_new_specific_checked (mono_class_vtable (domain, object_array_klass), sig->param_count, error);
+ return_val_if_nok (error, FALSE);
MONO_OBJECT_SETREF (this_obj, args, arr);
- arr = mono_array_new_specific_checked (mono_class_vtable (domain, byte_array_klass), sig->param_count, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ arr = mono_array_new_specific_checked (mono_class_vtable (domain, byte_array_klass), sig->param_count, error);
+ return_val_if_nok (error, FALSE);
MONO_OBJECT_SETREF (this_obj, arg_types, arr);
names = g_new (char *, sig->param_count);
mono_method_get_param_names (method->method, (const char **) names);
- arr = mono_array_new_specific_checked (mono_class_vtable (domain, string_array_klass), sig->param_count, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ arr = mono_array_new_specific_checked (mono_class_vtable (domain, string_array_klass), sig->param_count, error);
+ if (!is_ok (error))
+ goto fail;
MONO_OBJECT_SETREF (this_obj, names, arr);
for (i = 0; i < sig->param_count; i++) {
- name = mono_string_new (domain, names [i]);
+ name = mono_string_new_checked (domain, names [i], error);
+ if (!is_ok (error))
+ goto fail;
mono_array_setref (this_obj->names, i, name);
}
}
mono_array_set (this_obj->arg_types, guint8, i, arg_type);
}
+
+ return TRUE;
+fail:
+ g_free (names);
+ return FALSE;
}
#ifndef DISABLE_REMOTING
}
/**
- * mono_delegate_ctor:
+ * mono_delegate_ctor_with_method:
* @this: pointer to an uninitialized delegate object
* @target: target object
* @addr: pointer to native code
* @method: method
+ * @error: set on error.
*
* Initialize a delegate and sets a specific method, not the one
* associated with addr. This is useful when sharing generic code.
* In that case addr will most probably not be associated with the
* correct instantiation of the method.
+ * On failure returns FALSE and sets @error.
*/
-void
-mono_delegate_ctor_with_method (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoMethod *method)
+gboolean
+mono_delegate_ctor_with_method (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoMethod *method, MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
- MonoError error;
+ mono_error_init (error);
MonoDelegate *delegate = (MonoDelegate *)this_obj;
g_assert (this_obj);
if (target && target->vtable->klass == mono_defaults.transparent_proxy_class) {
g_assert (method);
method = mono_marshal_get_remoting_invoke (method);
- delegate->method_ptr = mono_compile_method_checked (method, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ delegate->method_ptr = mono_compile_method_checked (method, error);
+ return_val_if_nok (error, FALSE);
MONO_OBJECT_SETREF (delegate, target, target);
} else
#endif
delegate->invoke_impl = arch_create_delegate_trampoline (delegate->object.vtable->domain, delegate->object.vtable->klass);
if (callbacks.init_delegate)
callbacks.init_delegate (delegate);
+ return TRUE;
}
/**
* @this: pointer to an uninitialized delegate object
* @target: target object
* @addr: pointer to native code
+ * @error: set on error.
*
* This is used to initialize a delegate.
+ * On failure returns FALSE and sets @error.
*/
-void
-mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr)
+gboolean
+mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
+ mono_error_init (error);
MonoDomain *domain = mono_domain_get ();
MonoJitInfo *ji;
MonoMethod *method = NULL;
g_assert (!method->klass->generic_container);
}
- mono_delegate_ctor_with_method (this_obj, target, addr, method);
+ return mono_delegate_ctor_with_method (this_obj, target, addr, method, error);
}
/**
* @invoke: optional, delegate invoke.
* @cb: async callback delegate.
* @state: state passed to the async callback.
+ * @error: set on error.
*
* Translates arguments pointers into a MonoMethodMessage.
+ * On failure returns NULL and sets @error.
*/
MonoMethodMessage *
mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
- MonoDelegate **cb, MonoObject **state)
+ MonoDelegate **cb, MonoObject **state, MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
- MonoError error;
+ mono_error_init (error);
MonoDomain *domain = mono_domain_get ();
MonoMethodSignature *sig = mono_method_signature (method);
MonoMethodMessage *msg;
int i, count;
- msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, error);
+ return_val_if_nok (error, NULL);
if (invoke) {
- MonoReflectionMethod *rm = mono_method_get_object_checked (domain, invoke, NULL, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
- mono_message_init (domain, msg, rm, NULL);
+ MonoReflectionMethod *rm = mono_method_get_object_checked (domain, invoke, NULL, error);
+ return_val_if_nok (error, NULL);
+ mono_message_init (domain, msg, rm, NULL, error);
+ return_val_if_nok (error, NULL);
count = sig->param_count - 2;
} else {
- MonoReflectionMethod *rm = mono_method_get_object_checked (domain, method, NULL, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
- mono_message_init (domain, msg, rm, NULL);
+ MonoReflectionMethod *rm = mono_method_get_object_checked (domain, method, NULL, error);
+ return_val_if_nok (error, NULL);
+ mono_message_init (domain, msg, rm, NULL, error);
+ return_val_if_nok (error, NULL);
count = sig->param_count;
}
klass = mono_class_from_mono_type (sig->params [i]);
if (klass->valuetype) {
- arg = mono_value_box_checked (domain, klass, vpos, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ arg = mono_value_box_checked (domain, klass, vpos, error);
+ return_val_if_nok (error, NULL);
} else
arg = *((MonoObject **)vpos);
return_val_if_nok (error, NULL);
MonoReflectionMethod *rm = mono_method_get_object_checked (domain, getter, NULL, error);
return_val_if_nok (error, NULL);
- mono_message_init (domain, msg, rm, out_args);
+ mono_message_init (domain, msg, rm, out_args, error);
+ return_val_if_nok (error, NULL);
full_name = mono_type_get_full_name (klass);
mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
MonoReflectionMethod *rm = mono_method_get_object_checked (domain, getter, NULL, error);
return_val_if_nok (error, NULL);
- mono_message_init (domain, msg, rm, out_args);
+ mono_message_init (domain, msg, rm, out_args, error);
+ return_val_if_nok (error, NULL);
full_name = mono_type_get_full_name (klass);
mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
return_val_if_nok (error, FALSE);
MonoReflectionMethod *rm = mono_method_get_object_checked (domain, setter, NULL, error);
return_val_if_nok (error, FALSE);
- mono_message_init (domain, msg, rm, NULL);
+ mono_message_init (domain, msg, rm, NULL, error);
+ return_val_if_nok (error, FALSE);
full_name = mono_type_get_full_name (klass);
mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
return_val_if_nok (error, FALSE);
MonoReflectionMethod *rm = mono_method_get_object_checked (domain, setter, NULL, error);
return_val_if_nok (error, FALSE);
- mono_message_init (domain, msg, rm, NULL);
+ mono_message_init (domain, msg, rm, NULL, error);
+ return_val_if_nok (error, FALSE);
full_name = mono_type_get_full_name (klass);
mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
MONO_API MonoString*
mono_string_new_size (MonoDomain *domain, int32_t len);
+MONO_RT_EXTERNAL_ONLY
MONO_API MonoString*
mono_ldstr (MonoDomain *domain, MonoImage *image, uint32_t str_index);
register_icall (type_from_handle, "type_from_handle", "object ptr", FALSE);
register_icall (mono_marshal_set_domain_by_id, "mono_marshal_set_domain_by_id", "int32 int32 int32", FALSE);
register_icall (mono_marshal_check_domain_image, "mono_marshal_check_domain_image", "int32 int32 ptr", FALSE);
- register_icall (mono_marshal_xdomain_copy_value, "mono_marshal_xdomain_copy_value", "object object", FALSE);
+ register_icall (ves_icall_mono_marshal_xdomain_copy_value, "ves_icall_mono_marshal_xdomain_copy_value", "object object", FALSE);
register_icall (mono_marshal_xdomain_copy_out_value, "mono_marshal_xdomain_copy_out_value", "void object object", FALSE);
register_icall (mono_remoting_wrapper, "mono_remoting_wrapper", "object ptr ptr", FALSE);
register_icall (mono_upgrade_remote_class_wrapper, "mono_upgrade_remote_class_wrapper", "void object object", FALSE);
module_initialized = TRUE;
}
+/* This is an icall, it will return NULL and set pending exception on failure */
static MonoReflectionType *
type_from_handle (MonoType *handle)
{
mono_class_init (klass);
ret = mono_type_get_object_checked (domain, handle, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ mono_error_set_pending_exception (&error);
return ret;
}
return res;
}
- msg = mono_method_call_message_new (method, params, NULL, NULL, NULL);
+ msg = mono_method_call_message_new (method, params, NULL, NULL, NULL, &error);
+ if (!is_ok (&error))
+ goto fail;
res = mono_remoting_invoke ((MonoObject *)this_obj->rp, msg, &exc, &out_args, &error);
if (!is_ok (&error))
static void
mono_marshal_xdomain_copy_out_value (MonoObject *src, MonoObject *dst)
{
+ MonoError error;
if (src == NULL || dst == NULL) return;
g_assert (mono_object_class (src) == mono_object_class (dst));
int i, len = mono_array_length ((MonoArray *)dst);
for (i = 0; i < len; i++) {
MonoObject *item = (MonoObject *)mono_array_get ((MonoArray *)src, gpointer, i);
- mono_array_setref ((MonoArray *)dst, i, mono_marshal_xdomain_copy_value (item));
+ MonoObject *item_copy = mono_marshal_xdomain_copy_value (item, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
+ mono_array_setref ((MonoArray *)dst, i, item_copy);
}
} else {
mono_array_full_copy ((MonoArray *)src, (MonoArray *)dst);
static void
mono_marshal_emit_xdomain_copy_value (MonoMethodBuilder *mb, MonoClass *pclass)
{
- mono_mb_emit_icall (mb, mono_marshal_xdomain_copy_value);
+ mono_mb_emit_icall (mb, ves_icall_mono_marshal_xdomain_copy_value);
mono_mb_emit_op (mb, CEE_CASTCLASS, pclass);
}
* Makes a copy of "val" suitable for the current domain.
*/
MonoObject *
-mono_marshal_xdomain_copy_value (MonoObject *val)
+mono_marshal_xdomain_copy_value (MonoObject *val, MonoError *error)
{
- MonoError error;
+ mono_error_init (error);
MonoDomain *domain;
if (val == NULL) return NULL;
case MONO_TYPE_U8:
case MONO_TYPE_R4:
case MONO_TYPE_R8: {
- MonoObject *res = mono_value_box_checked (domain, mono_object_class (val), ((char*)val) + sizeof(MonoObject), &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ MonoObject *res = mono_value_box_checked (domain, mono_object_class (val), ((char*)val) + sizeof(MonoObject), error);
return res;
}
case MONO_TYPE_STRING: {
MonoString *str = (MonoString *) val;
MonoObject *res = NULL;
- res = (MonoObject *) mono_string_new_utf16_checked (domain, mono_string_chars (str), mono_string_length (str), &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ res = (MonoObject *) mono_string_new_utf16_checked (domain, mono_string_chars (str), mono_string_length (str), error);
return res;
}
case MONO_TYPE_ARRAY:
MonoArray *acopy;
MonoXDomainMarshalType mt = mono_get_xdomain_marshal_type (&(mono_object_class (val)->element_class->byval_arg));
if (mt == MONO_MARSHAL_SERIALIZE) return NULL;
- acopy = mono_array_clone_in_domain (domain, (MonoArray *) val, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ acopy = mono_array_clone_in_domain (domain, (MonoArray *) val, error);
+ return_val_if_nok (error, NULL);
if (mt == MONO_MARSHAL_COPY) {
int i, len = mono_array_length (acopy);
for (i = 0; i < len; i++) {
MonoObject *item = (MonoObject *)mono_array_get (acopy, gpointer, i);
- mono_array_setref (acopy, i, mono_marshal_xdomain_copy_value (item));
+ MonoObject *item_copy = mono_marshal_xdomain_copy_value (item, error);
+ return_val_if_nok (error, NULL);
+ mono_array_setref (acopy, i, item_copy);
}
}
return (MonoObject *) acopy;
return NULL;
}
+
+/* mono_marshal_xdomain_copy_value
+ * Makes a copy of "val" suitable for the current domain.
+ */
+MonoObject *
+ves_icall_mono_marshal_xdomain_copy_value (MonoObject *val)
+{
+ MonoError error;
+ MonoObject *result = mono_marshal_xdomain_copy_value (val, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
mono_error_init (error);
- message = mono_method_call_message_new (method, params, mono_get_delegate_invoke (method->klass), (params != NULL) ? (&async_callback) : NULL, (params != NULL) ? (&state) : NULL);
+ message = mono_method_call_message_new (method, params, mono_get_delegate_invoke (method->klass), (params != NULL) ? (&async_callback) : NULL, (params != NULL) ? (&state) : NULL, error);
+ return_val_if_nok (error, NULL);
async_call = (MonoAsyncCall*) mono_object_new_checked (domain, async_call_klass, error);
return_val_if_nok (error, NULL);
MONO_OBJECT_SETREF (async_call, cb_target, async_callback);
}
- async_result = mono_async_result_new (domain, NULL, async_call->state, NULL, (MonoObject*) async_call);
+ async_result = mono_async_result_new (domain, NULL, async_call->state, NULL, (MonoObject*) async_call, error);
+ return_val_if_nok (error, NULL);
MONO_OBJECT_SETREF (async_result, async_delegate, target);
mono_threadpool_ms_enqueue_work_item (domain, (MonoObject*) async_result, error);
// FIXME: Generics
switch (mono_metadata_token_code (token)) {
case MONO_TOKEN_STRING: {
+ MonoError error;
MonoString *s;
char *s2;
- s = mono_ldstr (domain, method->klass->image, mono_metadata_token_index (token));
- g_assert (s);
+ s = mono_ldstr_checked (domain, method->klass->image, mono_metadata_token_index (token), &error);
+ mono_error_assert_ok (&error); /* FIXME don't swallow the error */
s2 = mono_string_to_utf8 (s);
return addr;
}
+MonoString*
+ves_icall_mono_ldstr (MonoDomain *domain, MonoImage *image, guint32 idx)
+{
+ MonoError error;
+ MonoString *result = mono_ldstr_checked (domain, image, idx, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+
MonoString*
mono_helper_ldstr (MonoImage *image, guint32 idx)
{
- return mono_ldstr (mono_domain_get (), image, idx);
+ MonoError error;
+ MonoString *result = mono_ldstr_checked (mono_domain_get (), image, idx, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
MonoString*
mono_helper_ldstr_mscorlib (guint32 idx)
{
- return mono_ldstr (mono_domain_get (), mono_defaults.corlib, idx);
+ MonoError error;
+ MonoString *result = mono_ldstr_checked (mono_domain_get (), mono_defaults.corlib, idx, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
MonoObject*
mono_error_set_pending_exception (&error);
}
+void
+ves_icall_mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr)
+{
+ MonoError error;
+ mono_delegate_ctor (this_obj, target, addr, &error);
+ mono_error_set_pending_exception (&error);
+}
+
gpointer
mono_fill_class_rgctx (MonoVTable *vtable, int index)
{
gpointer mono_helper_compile_generic_method (MonoObject *obj, MonoMethod *method, gpointer *this_arg);
+MonoString*
+ves_icall_mono_ldstr (MonoDomain *domain, MonoImage *image, guint32 idx);
+
MonoString *mono_helper_ldstr (MonoImage *image, guint32 idx);
MonoString *mono_helper_ldstr_mscorlib (guint32 idx);
void
mono_generic_class_init (MonoVTable *vtable);
+void
+ves_icall_mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr);
+
MonoObject*
mono_gsharedvt_constrained_call (gpointer mp, MonoMethod *cmethod, MonoClass *klass, gboolean deref_arg, gpointer *args);
NULLIFY_INS (args [0]);
// FIXME: Ugly
- s = mono_ldstr (cfg->domain, ji->image, mono_metadata_token_index (ji->token));
+ s = mono_ldstr_checked (cfg->domain, ji->image, mono_metadata_token_index (ji->token), &cfg->error);
+ return_val_if_nok (&cfg->error, NULL);
MONO_INST_NEW (cfg, ins, OP_OBJC_GET_SELECTOR);
ins->dreg = mono_alloc_ireg (cfg);
// FIXME: Leaks
}
goto call_end;
}
-
+ CHECK_CFG_ERROR;
+
/* Inlining */
if ((cfg->opt & MONO_OPT_INLINE) &&
(!virtual_ || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
EMIT_NEW_IMAGECONST (cfg, iargs [1], image);
EMIT_NEW_ICONST (cfg, iargs [2], mono_metadata_token_index (n));
- *sp = mono_emit_jit_icall (cfg, mono_ldstr, iargs);
- mono_ldstr (cfg->domain, image, mono_metadata_token_index (n));
+ *sp = mono_emit_jit_icall (cfg, ves_icall_mono_ldstr, iargs);
+ mono_ldstr_checked (cfg->domain, image, mono_metadata_token_index (n), &cfg->error);
+ CHECK_CFG_ERROR;
} else {
if (cfg->cbb->out_of_line) {
MonoInst *iargs [2];
else {
NEW_PCONST (cfg, ins, NULL);
ins->type = STACK_OBJ;
- ins->inst_p0 = mono_ldstr (cfg->domain, image, mono_metadata_token_index (n));
+ ins->inst_p0 = mono_ldstr_checked (cfg->domain, image, mono_metadata_token_index (n), &cfg->error);
+ CHECK_CFG_ERROR;
+
if (!ins->inst_p0)
OUT_OF_MEMORY_FAILURE;
break;
case MONO_PATCH_INFO_LDSTR:
target =
- mono_ldstr (domain, patch_info->data.token->image,
- mono_metadata_token_index (patch_info->data.token->token));
+ mono_ldstr_checked (domain, patch_info->data.token->image,
+ mono_metadata_token_index (patch_info->data.token->token), error);
break;
case MONO_PATCH_INFO_TYPE_FROM_HANDLE: {
gpointer handle;
#endif
/* other jit icalls */
- register_icall (mono_delegate_ctor, "mono_delegate_ctor", "void object object ptr", FALSE);
+ register_icall (ves_icall_mono_delegate_ctor, "ves_icall_mono_delegate_ctor", "void object object ptr", FALSE);
register_icall (mono_class_static_field_address , "mono_class_static_field_address",
"ptr ptr ptr", FALSE);
register_icall (mono_ldtoken_wrapper, "mono_ldtoken_wrapper", "ptr ptr ptr ptr", FALSE);
register_icall (mono_ldtoken_wrapper_generic_shared, "mono_ldtoken_wrapper_generic_shared",
"ptr ptr ptr ptr", FALSE);
register_icall (mono_get_special_static_data, "mono_get_special_static_data", "ptr int", FALSE);
- register_icall (mono_ldstr, "mono_ldstr", "object ptr ptr int32", FALSE);
+ register_icall (ves_icall_mono_ldstr, "ves_icall_mono_ldstr", "object ptr ptr int32", FALSE);
register_icall (mono_helper_stelem_ref_check, "mono_helper_stelem_ref_check", "void object object", FALSE);
register_icall (ves_icall_object_new, "ves_icall_object_new", "object ptr ptr", FALSE);
register_icall (ves_icall_object_new_specific, "ves_icall_object_new_specific", "object ptr", FALSE);
if (method->klass->parent == mono_defaults.multicastdelegate_class) {
if (*name == '.' && (strcmp (name, ".ctor") == 0)) {
- MonoJitICallInfo *mi = mono_find_jit_icall_by_name ("mono_delegate_ctor");
+ MonoJitICallInfo *mi = mono_find_jit_icall_by_name ("ves_icall_mono_delegate_ctor");
g_assert (mi);
/*
* We need to make sure this wrapper
projects / mono.git / commitdiff