X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Futils%2Fmono-error.c;h=27f2b62fb248ff784d2f6dbc9b350f98a7613d07;hb=56b3c007f428d93b7f230d58744393ad69e4ca63;hp=a59f2a123fb112f62d245290be57a7c909920f8b;hpb=a5fc1343a36f9609a5bb2d7aa9142398f6887bbc;p=mono.git diff --git a/mono/utils/mono-error.c b/mono/utils/mono-error.c index a59f2a123fb..27f2b62fb24 100644 --- a/mono/utils/mono-error.c +++ b/mono/utils/mono-error.c @@ -1,5 +1,6 @@ -/* - * mono-error.c: Error handling code +/** + * \file + * Error handling code * * Authors: * Rodrigo Kumpera (rkumpera@novell.com) @@ -101,10 +102,9 @@ mono_error_init_flags (MonoError *oerror, unsigned short flags) /** * mono_error_init: - * @error: Pointer to MonoError struct to initialize - * - * Any function which takes a MonoError for purposes of reporting an error - * is required to call either this or mono_error_init_flags on entry. + * \param error Pointer to \c MonoError struct to initialize + * Any function which takes a \c MonoError for purposes of reporting an error + * is required to call either this or \c mono_error_init_flags on entry. */ void mono_error_init (MonoError *error) @@ -176,6 +176,17 @@ mono_error_get_error_code (MonoError *error) return error->error_code; } +const char* +mono_error_get_exception_name (MonoError *oerror) +{ + MonoErrorInternal *error = (MonoErrorInternal*)oerror; + + if (error->error_code == MONO_ERROR_NONE) + return NULL; + + return error->exception_name; +} + /*Return a pointer to the internal error message, might be NULL. Caller should not release it.*/ const char* @@ -297,7 +308,7 @@ mono_error_set_assembly_load_simple (MonoError *oerror, const char *assembly_nam if (refection_only) mono_error_set_assembly_load (oerror, assembly_name, "Cannot resolve dependency to assembly because it has not been preloaded. When using the ReflectionOnly APIs, dependent assemblies must be pre-loaded or loaded on demand through the ReflectionOnlyAssemblyResolve event."); else - mono_error_set_assembly_load (oerror, assembly_name, "Could not load file or assembly or one of its dependencies."); + mono_error_set_assembly_load (oerror, assembly_name, "Could not load file or assembly '%s' or one of its dependencies.", assembly_name); } void @@ -459,6 +470,20 @@ mono_error_set_invalid_operation (MonoError *oerror, const char *msg_format, ... va_end (args); } +/** + * mono_error_set_file_not_found: + * + * System.IO.FileNotFoundException + */ +void +mono_error_set_file_not_found (MonoError *oerror, const char *msg_format, ...) +{ + va_list args; + va_start (args, msg_format); + mono_error_set_generic_errorv (oerror, "System.IO", "FileNotFoundException", msg_format, args); + va_end (args); +} + void mono_error_set_invalid_program (MonoError *oerror, const char *msg_format, ...) { @@ -470,6 +495,17 @@ mono_error_set_invalid_program (MonoError *oerror, const char *msg_format, ...) set_error_message (); } +/** + * mono_error_set_invalid_cast: + * + * System.InvalidCastException + */ +void +mono_error_set_invalid_cast (MonoError *oerror) +{ + mono_error_set_generic_error (oerror, "System", "InvalidCastException", ""); +} + void mono_error_set_exception_instance (MonoError *oerror, MonoException *exc) { @@ -480,6 +516,16 @@ mono_error_set_exception_instance (MonoError *oerror, MonoException *exc) error->exn.instance_handle = mono_gchandle_new (exc ? &exc->object : NULL, FALSE); } +void +mono_error_set_exception_handle (MonoError *oerror, MonoExceptionHandle exc) +{ + MonoErrorInternal *error = (MonoErrorInternal*)oerror; + + mono_error_prepare (error); + error->error_code = MONO_ERROR_EXCEPTION_INSTANCE; + error->exn.instance_handle = mono_gchandle_from_handle (MONO_HANDLE_CAST(MonoObject, exc), FALSE); +} + void mono_error_set_out_of_memory (MonoError *oerror, const char *msg_format, ...) { @@ -531,20 +577,30 @@ mono_error_set_not_verifiable (MonoError *oerror, MonoMethod *method, const char } +/* Used by mono_error_prepare_exception - it sets its own error on mono_string_new_checked failure. */ +static MonoString* +string_new_cleanup (MonoDomain *domain, const char *text) +{ + MonoError ignored_err; + MonoString *result = mono_string_new_checked (domain, text, &ignored_err); + mono_error_cleanup (&ignored_err); + return result; +} + static MonoString* get_type_name_as_mono_string (MonoErrorInternal *error, MonoDomain *domain, MonoError *error_out) { MonoString* res = NULL; if (error->type_name) { - res = mono_string_new (domain, error->type_name); + res = string_new_cleanup (domain, error->type_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); + res = string_new_cleanup (domain, name); g_free (name); } } @@ -557,7 +613,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 (), error->full_message); + MonoString *msg = string_new_cleanup (mono_domain_get (), error->full_message); if (msg) MONO_OBJECT_SETREF (exception, message, msg); else @@ -574,7 +630,7 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) MonoString *assembly_name = NULL, *type_name = NULL, *method_name = NULL, *field_name = NULL, *msg = NULL; MonoDomain *domain = mono_domain_get (); - mono_error_init (error_out); + error_init (error_out); switch (error->error_code) { case MONO_ERROR_NONE: @@ -586,7 +642,7 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) if (!mono_error_ok (error_out)) break; - method_name = mono_string_new (domain, error->member_name); + method_name = string_new_cleanup (domain, error->member_name); if (!method_name) { mono_error_set_out_of_memory (error_out, "Could not allocate method name"); break; @@ -606,7 +662,7 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) if (!mono_error_ok (error_out)) break; - field_name = mono_string_new (domain, error->member_name); + field_name = string_new_cleanup (domain, error->member_name); if (!field_name) { mono_error_set_out_of_memory (error_out, "Could not allocate field name"); break; @@ -627,11 +683,13 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) break; if (error->assembly_name) { - assembly_name = mono_string_new (domain, error->assembly_name); + assembly_name = string_new_cleanup (domain, error->assembly_name); if (!assembly_name) { mono_error_set_out_of_memory (error_out, "Could not allocate assembly name"); break; } + } else { + assembly_name = mono_string_empty (domain); } exception = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System", "TypeLoadException", type_name, assembly_name, error_out); @@ -645,14 +703,14 @@ mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) case MONO_ERROR_FILE_NOT_FOUND: case MONO_ERROR_BAD_IMAGE: if (error->assembly_name) { - msg = mono_string_new (domain, error->full_message); + msg = string_new_cleanup (domain, error->full_message); if (!msg) { mono_error_set_out_of_memory (error_out, "Could not allocate message"); break; } if (error->assembly_name) { - assembly_name = mono_string_new (domain, error->assembly_name); + assembly_name = string_new_cleanup (domain, error->assembly_name); if (!assembly_name) { mono_error_set_out_of_memory (error_out, "Could not allocate assembly name"); break; @@ -770,19 +828,17 @@ void mono_error_move (MonoError *dest, MonoError *src) { memcpy (dest, src, sizeof (MonoErrorInternal)); - mono_error_init (src); + error_init (src); } /** * mono_error_box: - * @ierror: The input error that will be boxed. - * @image: The mempool of this image will hold the boxed error. - * - * Creates a new boxed error in the given mempool from MonoError. - * It does not alter ierror, so you still have to clean it up with - * mono_error_cleanup or mono_error_convert_to_exception or another such function. - * - * Returns the boxed error, or NULL if the mempool could not allocate. + * \param ierror The input error that will be boxed. + * \param image The mempool of this image will hold the boxed error. + * Creates a new boxed error in the given mempool from \c MonoError. + * It does not alter \p ierror, so you still have to clean it up with + * \c mono_error_cleanup or \c mono_error_convert_to_exception or another such function. + * \returns the boxed error, or NULL if the mempool could not allocate. */ MonoErrorBoxed* mono_error_box (const MonoError *ierror, MonoImage *image) @@ -823,16 +879,14 @@ mono_error_box (const MonoError *ierror, MonoImage *image) /** * mono_error_set_from_boxed: - * @oerror: The error that will be set to the contents of the box. - * @box: A mempool-allocated error. - * + * \param oerror The error that will be set to the contents of the box. + * \param box A mempool-allocated error. * Sets the error condition in the oerror from the contents of the * given boxed error. Does not alter the boxed error, so it can be - * used in a future call to mono_error_set_from_boxed as needed. The - * oerror should've been previously initialized with mono_error_init, + * used in a future call to \c mono_error_set_from_boxed as needed. The + * \p oerror should've been previously initialized with \c mono_error_init, * as usual. - * - * Returns TRUE on success or FALSE on failure. + * \returns TRUE on success or FALSE on failure. */ gboolean mono_error_set_from_boxed (MonoError *oerror, const MonoErrorBoxed *box)