X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Futils%2Fmono-error.c;h=4ac7d6766ef2ddb4646c5b8d17be039edc4d468f;hb=69f207ee9e4f440e66e98bf5f685807f6527c39d;hp=841a354afaff6f61ea232b97a6a82be54d4af8d8;hpb=559ad5b34bc086b51af2e589b32ea2eae0f78820;p=mono.git diff --git a/mono/utils/mono-error.c b/mono/utils/mono-error.c index 841a354afaf..7bc5950e4b8 100644 --- a/mono/utils/mono-error.c +++ b/mono/utils/mono-error.c @@ -4,6 +4,7 @@ * Authors: * Rodrigo Kumpera (rkumpera@novell.com) * Copyright 2009 Novell, Inc (http://www.novell.com) + * Licensed under the MIT license. See LICENSE file in the project root for full license information. */ #include @@ -11,32 +12,49 @@ #include "mono-error-internals.h" #include -#include #include +#include -#define mono_internal_error_get_message(E) ((E)->full_message ? (E)->full_message : (E)->message) +#define set_error_messagev() do { \ + if (!(error->full_message = g_strdup_vprintf (msg_format, args))) \ + error->flags |= MONO_ERROR_INCOMPLETE; \ +} while (0) #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))) \ - error->flags |= MONO_ERROR_INCOMPLETE; \ - } \ + set_error_messagev(); \ va_end (args); \ } while (0) +static void +mono_error_set_generic_errorv (MonoError *oerror, const char *name_space, const char *name, const char *msg_format, va_list args); + +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 = error->full_message_with_fields = 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* @@ -44,8 +62,9 @@ get_type_name (MonoErrorInternal *error) { if (error->type_name) return error->type_name; - if (error->klass) - return error->klass->name; + MonoClass *klass = get_class (error); + if (klass) + return klass->name; return ""; } @@ -54,8 +73,9 @@ get_assembly_name (MonoErrorInternal *error) { if (error->assembly_name) return error->assembly_name; - if (error->klass && error->klass->image) - return error->klass->image->name; + MonoClass *klass = get_class (error); + if (klass && klass->image) + return klass->image->name; return ""; } @@ -82,6 +102,9 @@ mono_error_cleanup (MonoError *oerror) 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 @@ -92,6 +115,7 @@ mono_error_cleanup (MonoError *oerror) 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 @@ -101,12 +125,12 @@ mono_error_ok (MonoError *error) } void -mono_error_assert_ok (MonoError *error) +mono_error_assert_ok_pos (MonoError *error, const char* filename, int lineno) { if (mono_error_ok (error)) return; - g_error ("%s\n", mono_error_get_message (error)); + g_error ("%s:%d: %s\n", filename, lineno, mono_error_get_message (error)); } unsigned short @@ -127,12 +151,12 @@ mono_error_get_message (MonoError *oerror) return error->full_message_with_fields; error->full_message_with_fields = g_strdup_printf ("%s assembly:%s type:%s member:%s", - mono_internal_error_get_message (error), + error->full_message, get_assembly_name (error), get_type_name (error), error->member_name ? error->member_name : ""); - return error->full_message_with_fields ? error->full_message_with_fields : mono_internal_error_get_message (error); + return error->full_message_with_fields ? error->full_message_with_fields : error->full_message; } /* @@ -157,6 +181,7 @@ mono_error_dup_strings (MonoError *oerror, gboolean dup_strings) DUP_STR (member_name); DUP_STR (exception_name_space); DUP_STR (exception_name); + DUP_STR (first_argument); } #undef DUP_STR } @@ -201,7 +226,9 @@ mono_error_set_class (MonoError *oerror, MonoClass *klass) { MonoErrorInternal *error = (MonoErrorInternal*)oerror; - error->klass = klass; + if (is_managed_exception (error)) + return; + error->exn.klass = klass; } static void @@ -311,131 +338,86 @@ mono_error_set_bad_image (MonoError *oerror, MonoImage *image, const char *msg_f } void -mono_error_set_generic_error (MonoError *oerror, const char * name_space, const char *name, const char *msg_format, ...) +mono_error_set_generic_errorv (MonoError *oerror, const char *name_space, const char *name, const char *msg_format, va_list args) { MonoErrorInternal *error = (MonoErrorInternal*)oerror; mono_error_prepare (error); error->error_code = MONO_ERROR_GENERIC; mono_error_set_corlib_exception (oerror, name_space, name); - set_error_message (); + set_error_messagev (); } void -mono_error_set_from_loader_error (MonoError *oerror) +mono_error_set_generic_error (MonoError *oerror, const char * name_space, const char *name, const char *msg_format, ...) { - MonoLoaderError *loader_error = mono_loader_get_last_error (); - MonoErrorInternal *error = (MonoErrorInternal*)oerror; - gboolean dup_strings = TRUE; - - mono_error_prepare (error); - - if (!loader_error) { - mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from an empty loader-error"); - return; - } - - switch (loader_error->exception_type) { - 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_INVALID_PROGRAM: - mono_error_set_generic_error (oerror, "System", "InvalidProgramException", "Failed for unknown reasons."); - break; - - case MONO_EXCEPTION_UNVERIFIABLE_IL: - mono_error_set_generic_error (oerror, "System.Security", "VerificationException", "Failed for unknown reasons."); - break; - - case MONO_EXCEPTION_MISSING_METHOD: - 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."); - break; - - case MONO_EXCEPTION_MISSING_FIELD: - mono_error_set_field_load (oerror, loader_error->klass, loader_error->member_name, "Failed for unknown reasons."); - break; - - case MONO_EXCEPTION_TYPE_LOAD: - mono_error_set_type_load_name (oerror, g_strdup (loader_error->class_name), g_strdup (loader_error->assembly_name), "Failed for unknown reasons."); - dup_strings = FALSE; - break; - - case MONO_EXCEPTION_FILE_NOT_FOUND: - mono_error_set_assembly_load_simple (oerror, loader_error->assembly_name, loader_error->ref_only); - break; - - case MONO_EXCEPTION_METHOD_ACCESS: - mono_error_set_generic_error (oerror, "System", "MethodAccessException", "Failed for unknown reasons."); - break; - - case MONO_EXCEPTION_FIELD_ACCESS: - mono_error_set_generic_error (oerror, "System", "FieldAccessException", "Failed for unknown reasons."); - break; - - case MONO_EXCEPTION_OBJECT_SUPPLIED: - case MONO_EXCEPTION_GENERIC_SHARING_FAILED: - mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from JIT internal error %d", loader_error->exception_type); - break; - - case MONO_EXCEPTION_BAD_IMAGE: - mono_error_set_bad_image_name (oerror, "", "%s", loader_error->msg); - break; + va_list args; + va_start (args, msg_format); + mono_error_set_generic_errorv (oerror, name_space, name, msg_format, args); + va_end (args); +} - case MONO_EXCEPTION_OUT_OF_MEMORY: - mono_error_set_out_of_memory (oerror, "Failed for unknown reasons."); - break; +/** + * mono_error_set_not_implemented: + * + * System.NotImplementedException + */ +void +mono_error_set_not_implemented (MonoError *oerror, const char *msg_format, ...) +{ + va_list args; + va_start (args, msg_format); + mono_error_set_generic_errorv (oerror, "System", "NotImplementedException", msg_format, args); + va_end (args); +} - default: - mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce an unknown loader-error %d", loader_error->exception_type); - break; - } +/** + * mono_error_set_execution_engine: + * + * System.ExecutionEngineException + */ +void +mono_error_set_execution_engine (MonoError *oerror, const char *msg_format, ...) +{ + va_list args; + va_start (args, msg_format); + mono_error_set_generic_errorv (oerror, "System", "ExecutionEngineException", msg_format, args); + va_end (args); +} - mono_error_dup_strings (oerror, dup_strings); - mono_loader_clear_error (); +/** + * mono_error_set_execution_engine: + * + * System.NotSupportedException + */ +void +mono_error_set_not_supported (MonoError *oerror, const char *msg_format, ...) +{ + va_list args; + va_start (args, msg_format); + mono_error_set_generic_errorv (oerror, "System", "NotSupportedException", msg_format, args); + va_end (args); } void -mono_loader_set_error_from_mono_error (MonoError *oerror) +mono_error_set_exception_instance (MonoError *oerror, MonoException *exc) { MonoErrorInternal *error = (MonoErrorInternal*)oerror; - switch (error->error_code) { - case MONO_ERROR_MISSING_METHOD: - 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); - break; - case MONO_ERROR_TYPE_LOAD: - mono_loader_set_error_type_load (get_type_name (error), get_assembly_name (error)); - break; - case MONO_ERROR_FILE_NOT_FOUND: - /* XXX can't recover if it's ref only or not */ - 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))); - break; - default: - mono_loader_set_error_bad_image (g_strdup_printf ("Non translatable error: %s", mono_internal_error_get_message (error))); - } + 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_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 @@ -445,7 +427,19 @@ mono_error_set_argument (MonoError *oerror, const char *argument, const char *ms 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 (); } @@ -474,11 +468,14 @@ get_type_name_as_mono_string (MonoErrorInternal *error, MonoDomain *domain, Mono 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) @@ -489,7 +486,7 @@ get_type_name_as_mono_string (MonoErrorInternal *error, MonoDomain *domain, Mono 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 @@ -513,7 +510,7 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) 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; @@ -528,12 +525,12 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) 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; @@ -548,12 +545,12 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) 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; case MONO_ERROR_TYPE_LOAD: - if (error->type_name || error->assembly_name) { + if ((error->type_name && error->assembly_name) || error->exn.klass) { type_name = get_type_name_as_mono_string (error, domain, error_out); if (!mono_error_ok (error_out)) break; @@ -570,14 +567,14 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) 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; @@ -597,9 +594,9 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) 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; @@ -608,19 +605,23 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) 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"); @@ -633,13 +634,17 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) } case MONO_ERROR_GENERIC: 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"); + mono_error_set_execution_engine (error_out, "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_set_generic_error (error_out, "System", "ExecutionEngineException", "Invalid error-code %d", error->error_code); + mono_error_set_execution_engine (error_out, "Invalid error-code %d", error->error_code); } if (!mono_error_ok (error_out)) @@ -675,3 +680,10 @@ mono_error_convert_to_exception (MonoError *target_error) mono_error_cleanup (target_error); return ex; } + +void +mono_error_move (MonoError *dest, MonoError *src) +{ + memcpy (dest, src, sizeof (MonoErrorInternal)); + mono_error_init (src); +}