#include "mono-error-internals.h"
#include <mono/metadata/exception.h>
-#include <mono/metadata/object-internals.h>
#include <mono/metadata/class-internals.h>
#include <mono/metadata/debug-helpers.h>
-
-#define mono_internal_error_get_message(E) ((E)->full_message ? (E)->full_message : (E)->message)
+#include <mono/metadata/object.h>
+#include <mono/metadata/object-internals.h>
#define set_error_message() do { \
va_list args; \
va_start (args, msg_format); \
- if (g_vsnprintf (error->message, sizeof (error->message), msg_format, args) >= sizeof (error->message)) {\
- va_end (args); \
- va_start (args, msg_format); \
- if (!(error->full_message = g_strdup_vprintf (msg_format, args))) \
+ if (!(error->full_message = g_strdup_vprintf (msg_format, args))) \
error->flags |= MONO_ERROR_INCOMPLETE; \
- } \
va_end (args); \
} while (0)
+static gboolean
+is_managed_exception (MonoErrorInternal *error)
+{
+ return (error->error_code == MONO_ERROR_EXCEPTION_INSTANCE);
+}
+
static void
mono_error_prepare (MonoErrorInternal *error)
{
if (error->error_code != MONO_ERROR_NONE)
return;
- error->type_name = error->assembly_name = error->member_name = error->full_message = error->exception_name_space = error->exception_name = NULL;
- error->klass = NULL;
- error->message [0] = 0;
+ error->type_name = error->assembly_name = error->member_name = error->full_message = error->exception_name_space = error->exception_name = error->full_message_with_fields = error->first_argument = NULL;
+ error->exn.klass = NULL;
+}
+
+static MonoClass*
+get_class (MonoErrorInternal *error)
+{
+ MonoClass *klass = NULL;
+ if (is_managed_exception (error))
+ klass = mono_object_class (mono_gchandle_get_target (error->exn.instance_handle));
+ else
+ klass = error->exn.klass;
+ return klass;
+}
+
+static const char*
+get_type_name (MonoErrorInternal *error)
+{
+ if (error->type_name)
+ return error->type_name;
+ MonoClass *klass = get_class (error);
+ if (klass)
+ return klass->name;
+ return "<unknown type>";
+}
+
+static const char*
+get_assembly_name (MonoErrorInternal *error)
+{
+ if (error->assembly_name)
+ return error->assembly_name;
+ MonoClass *klass = get_class (error);
+ if (klass && klass->image)
+ return klass->image->name;
+ return "<unknown assembly>";
}
void
if (error->error_code == MONO_ERROR_NONE)
return;
+ if (is_managed_exception (error))
+ mono_gchandle_free (error->exn.instance_handle);
+
g_free ((char*)error->full_message);
+ g_free ((char*)error->full_message_with_fields);
if (!(error->flags & MONO_ERROR_FREE_STRINGS)) //no memory was allocated
return;
g_free ((char*)error->member_name);
g_free ((char*)error->exception_name_space);
g_free ((char*)error->exception_name);
+ g_free ((char*)error->first_argument);
}
gboolean
return error->error_code == MONO_ERROR_NONE;
}
+void
+mono_error_assert_ok_pos (MonoError *error, const char* filename, int lineno)
+{
+ if (mono_error_ok (error))
+ return;
+
+ g_error ("%s:%d: %s\n", filename, lineno, mono_error_get_message (error));
+}
+
unsigned short
mono_error_get_error_code (MonoError *error)
{
MonoErrorInternal *error = (MonoErrorInternal*)oerror;
if (error->error_code == MONO_ERROR_NONE)
return NULL;
- return mono_internal_error_get_message (error);
+ if (error->full_message_with_fields)
+ return error->full_message_with_fields;
+
+ error->full_message_with_fields = g_strdup_printf ("%s assembly:%s type:%s member:%s",
+ error->full_message,
+ get_assembly_name (error),
+ get_type_name (error),
+ error->member_name ? error->member_name : "<none>");
+
+ return error->full_message_with_fields ? error->full_message_with_fields : error->full_message;
}
/*
DUP_STR (member_name);
DUP_STR (exception_name_space);
DUP_STR (exception_name);
+ DUP_STR (first_argument);
}
#undef DUP_STR
}
{
MonoErrorInternal *error = (MonoErrorInternal*)oerror;
- error->klass = klass;
+ if (is_managed_exception (error))
+ return;
+ error->exn.klass = klass;
}
static void
set_error_message ();
}
+void
+mono_error_set_exception_instance (MonoError *oerror, MonoException *exc)
+{
+ MonoErrorInternal *error = (MonoErrorInternal*)oerror;
+
+ mono_error_prepare (error);
+ error->error_code = MONO_ERROR_EXCEPTION_INSTANCE;
+ error->exn.instance_handle = mono_gchandle_new (exc ? &exc->object : NULL, FALSE);
+}
+
void
mono_error_set_from_loader_error (MonoError *oerror)
{
case MONO_EXCEPTION_NONE:
mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from a non-error loader-error");
break;
- case MONO_EXCEPTION_SECURITY_LINKDEMAND:
- case MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND:
- mono_error_set_generic_error (oerror, "System.Security", "SecurityException", "Failed for unknown reasons.");
- break;
case MONO_EXCEPTION_INVALID_PROGRAM:
mono_error_set_generic_error (oerror, "System", "InvalidProgramException", "Failed for unknown reasons.");
error->error_code = MONO_ERROR_MISSING_METHOD;
mono_error_set_type_name (oerror, loader_error->class_name);
mono_error_set_member_name (oerror, loader_error->member_name);
- g_snprintf (error->message, sizeof (error->message), "Failed for unknown reasons.");
+ error->full_message = g_strdup ("Failed for unknown reasons.");
break;
case MONO_EXCEPTION_MISSING_FIELD:
mono_loader_clear_error ();
}
-static const char*
-get_type_name (MonoErrorInternal *error)
-{
- if (error->type_name)
- return error->type_name;
- if (error->klass)
- return error->klass->name;
- return "<unknown type>";
-}
-
-static const char*
-get_assembly_name (MonoErrorInternal *error)
-{
- if (error->assembly_name)
- return error->assembly_name;
- if (error->klass && error->klass->image)
- return error->klass->image->name;
- return "<unknown assembly>";
-}
-
void
mono_loader_set_error_from_mono_error (MonoError *oerror)
{
mono_loader_set_error_method_load (get_type_name (error), error->member_name);
break;
case MONO_ERROR_MISSING_FIELD:
- mono_loader_set_error_field_load (error->klass, error->member_name);
+ mono_loader_set_error_field_load (error->exn.klass, error->member_name);
break;
case MONO_ERROR_TYPE_LOAD:
mono_loader_set_error_type_load (get_type_name (error), get_assembly_name (error));
mono_loader_set_error_assembly_load (get_assembly_name (error), FALSE);
break;
case MONO_ERROR_BAD_IMAGE:
- mono_loader_set_error_bad_image (g_strdup (mono_internal_error_get_message (error)));
+ mono_loader_set_error_bad_image (g_strdup (error->full_message));
break;
+ case MONO_ERROR_EXCEPTION_INSTANCE:
+ mono_loader_set_error_bad_image (g_strdup_printf ("Non translatable error"));
default:
- mono_loader_set_error_bad_image (g_strdup_printf ("Non translatable error: %s", mono_internal_error_get_message (error)));
+ mono_loader_set_error_bad_image (g_strdup_printf ("Non translatable error: %s", error->full_message));
}
}
mono_error_set_out_of_memory (MonoError *oerror, const char *msg_format, ...)
{
MonoErrorInternal *error = (MonoErrorInternal*)oerror;
- va_list args;
mono_error_prepare (error);
error->error_code = MONO_ERROR_OUT_OF_MEMORY;
- va_start (args, msg_format);
- g_vsnprintf (error->message, sizeof (error->message), msg_format, args);
- va_end (args);
+
+ set_error_message ();
}
void
mono_error_prepare (error);
error->error_code = MONO_ERROR_ARGUMENT;
- error->type_name = argument; /*use the first available string slot*/
+ error->first_argument = argument;
+
+ set_error_message ();
+}
+
+void
+mono_error_set_argument_null (MonoError *oerror, const char *argument, const char *msg_format, ...)
+{
+ MonoErrorInternal *error = (MonoErrorInternal*)oerror;
+ mono_error_prepare (error);
+
+ error->error_code = MONO_ERROR_ARGUMENT_NULL;
+ error->first_argument = argument;
set_error_message ();
}
if (error->type_name) {
res = mono_string_new (domain, error->type_name);
- } else if (error->klass) {
- char *name = mono_type_full_name (&error->klass->byval_arg);
- if (name) {
- res = mono_string_new (domain, name);
- g_free (name);
+ } else {
+ MonoClass *klass = get_class (error);
+ if (klass) {
+ char *name = mono_type_full_name (&klass->byval_arg);
+ if (name) {
+ res = mono_string_new (domain, name);
+ g_free (name);
+ }
}
}
if (!res)
static void
set_message_on_exception (MonoException *exception, MonoErrorInternal *error, MonoError *error_out)
{
- MonoString *msg = mono_string_new (mono_domain_get (), mono_internal_error_get_message (error));
+ MonoString *msg = mono_string_new (mono_domain_get (), error->full_message);
if (msg)
MONO_OBJECT_SETREF (exception, message, msg);
else
return NULL;
case MONO_ERROR_MISSING_METHOD:
- if ((error->type_name || error->klass) && error->member_name) {
+ if ((error->type_name || error->exn.klass) && error->member_name) {
type_name = get_type_name_as_mono_string (error, domain, error_out);
if (!mono_error_ok (error_out))
break;
if (exception)
set_message_on_exception (exception, error, error_out);
} else {
- exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "MissingMethodException", mono_internal_error_get_message (error));
+ exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "MissingMethodException", error->full_message);
}
break;
case MONO_ERROR_MISSING_FIELD:
- if ((error->type_name || error->klass) && error->member_name) {
+ if ((error->type_name || error->exn.klass) && error->member_name) {
type_name = get_type_name_as_mono_string (error, domain, error_out);
if (!mono_error_ok (error_out))
break;
if (exception)
set_message_on_exception (exception, error, error_out);
} else {
- exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "MissingFieldException", mono_internal_error_get_message (error));
+ exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "MissingFieldException", error->full_message);
}
break;
if (exception)
set_message_on_exception (exception, error, error_out);
} else {
- exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "TypeLoadException", mono_internal_error_get_message (error));
+ exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "TypeLoadException", error->full_message);
}
break;
case MONO_ERROR_FILE_NOT_FOUND:
case MONO_ERROR_BAD_IMAGE:
if (error->assembly_name) {
- msg = mono_string_new (domain, mono_internal_error_get_message (error));
+ msg = mono_string_new (domain, error->full_message);
if (!msg) {
mono_error_set_out_of_memory (error_out, "Could not allocate message");
break;
exception = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "BadImageFormatException", msg, assembly_name);
} else {
if (error->error_code == MONO_ERROR_FILE_NOT_FOUND)
- exception = mono_exception_from_name_msg (mono_get_corlib (), "System.IO", "FileNotFoundException", mono_internal_error_get_message (error));
+ exception = mono_exception_from_name_msg (mono_get_corlib (), "System.IO", "FileNotFoundException", error->full_message);
else
- exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "BadImageFormatException", mono_internal_error_get_message (error));
+ exception = mono_exception_from_name_msg (mono_defaults.corlib, "System", "BadImageFormatException", error->full_message);
}
break;
break;
case MONO_ERROR_ARGUMENT:
- exception = mono_get_exception_argument (error->type_name, mono_internal_error_get_message (error));
+ exception = mono_get_exception_argument (error->first_argument, error->full_message);
+ break;
+
+ case MONO_ERROR_ARGUMENT_NULL:
+ exception = mono_get_exception_argument_null (error->first_argument);
break;
case MONO_ERROR_NOT_VERIFIABLE: {
char *type_name = NULL, *message;
- if (error->klass) {
- type_name = mono_type_get_full_name (error->klass);
+ if (error->exn.klass) {
+ type_name = mono_type_get_full_name (error->exn.klass);
if (!type_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate message");
break;
}
}
- message = g_strdup_printf ("Error in %s:%s %s", type_name, error->member_name, mono_internal_error_get_message (error));
+ message = g_strdup_printf ("Error in %s:%s %s", type_name, error->member_name, error->full_message);
if (!message) {
g_free (type_name);
mono_error_set_out_of_memory (error_out, "Could not allocate message");
if (!error->exception_name_space || !error->exception_name)
mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "MonoError with generic error but no exception name was supplied");
else
- exception = mono_exception_from_name_msg (mono_defaults.corlib, error->exception_name_space, error->exception_name, mono_internal_error_get_message (error));
+ exception = mono_exception_from_name_msg (mono_defaults.corlib, error->exception_name_space, error->exception_name, error->full_message);
+ break;
+
+ case MONO_ERROR_EXCEPTION_INSTANCE:
+ exception = (MonoException*) mono_gchandle_get_target (error->exn.instance_handle);
break;
default:
mono_error_cleanup (target_error);
return ex;
}
-
-
-/*
-Raises the exception of @error.
-Does nothing if @error has a success error code.
-Aborts in case of a double fault. This happens when it can't recover from an error caused by trying
-to construct the first exception object.
-The error object @error is cleaned up.
-*/
-void
-mono_error_raise_exception (MonoError *target_error)
-{
- MonoException *ex = mono_error_convert_to_exception (target_error);
- if (ex)
- mono_raise_exception (ex);
-}
projects / mono.git / blobdiff