X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fexception.c;h=ee10668e20d247ff82d058cafc5dc8690204c455;hb=e7951e6ee0786855af92d677d5fb20fe14f5ecdf;hp=725161488c607a6b25f1f4aaf5bc0946b3081b47;hpb=5e6643734df34c002b914b3d44c91ed897a8a6d6;p=mono.git diff --git a/mono/metadata/exception.c b/mono/metadata/exception.c index 725161488c6..ee10668e20d 100644 --- a/mono/metadata/exception.c +++ b/mono/metadata/exception.c @@ -7,11 +7,13 @@ * Dick Porter (dick@ximian.com) * Miguel de Icaza (miguel@ximian.com) * - * (C) 2001, 2002 Ximian, Inc. + * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com) + * Copyright 2004-2009 Novell, Inc (http://www.novell.com) */ #include #include +#include #include #include @@ -21,7 +23,8 @@ * @name_space: the namespace for the class * @name: class name * - * Creates an exception of the given namespace/name class. + * Creates an exception of the given namespace/name class in the + * current domain. * * Returns: the initialized exception instance. */ @@ -32,19 +35,36 @@ mono_exception_from_name (MonoImage *image, const char *name_space, return mono_exception_from_name_domain (mono_domain_get (), image, name_space, name); } +/** + * mono_exception_from_name_domain: + * @domain: Domain where the return object will be created. + * @image: the Mono image where to look for the class + * @name_space: the namespace for the class + * @name: class name + * + * Creates an exception object of the given namespace/name class on + * the given domain. + * + * Returns: the initialized exception instance. + */ MonoException * mono_exception_from_name_domain (MonoDomain *domain, MonoImage *image, const char* name_space, const char *name) { MonoClass *klass; MonoObject *o; + MonoDomain *caller_domain = mono_domain_get (); klass = mono_class_from_name (image, name_space, name); o = mono_object_new (domain, klass); g_assert (o != NULL); - + + if (domain != caller_domain) + mono_domain_set_internal (domain); mono_runtime_object_init (o); + if (domain != caller_domain) + mono_domain_set_internal (caller_domain); return (MonoException *)o; } @@ -75,25 +95,10 @@ mono_exception_from_token (MonoImage *image, guint32 token) return (MonoException *)o; } -/** - * mono_exception_from_name_two_strings: - * @image: the Mono image where to look for the class - * @name_space: the namespace for the class - * @name: class name - * @a1: first string argument to pass - * @a2: second string argument to pass - * - * Creates an exception from a constructor that takes two string - * arguments. - * - * Returns: the initialized exception instance. - */ -MonoException * -mono_exception_from_name_two_strings (MonoImage *image, const char *name_space, - const char *name, MonoString *a1, MonoString *a2) +static MonoException * +create_exception_two_strings (MonoClass *klass, MonoString *a1, MonoString *a2) { MonoDomain *domain = mono_domain_get (); - MonoClass *klass; MonoMethod *method = NULL; MonoObject *o; int count = 1; @@ -104,7 +109,6 @@ mono_exception_from_name_two_strings (MonoImage *image, const char *name_space, if (a2 != NULL) count++; - klass = mono_class_from_name (image, name_space, name); o = mono_object_new (domain, klass); iter = NULL; @@ -122,6 +126,7 @@ mono_exception_from_name_two_strings (MonoImage *image, const char *name_space, if (count == 2 && sig->params [1]->type != MONO_TYPE_STRING) continue; method = m; + break; } args [0] = a1; @@ -130,6 +135,28 @@ mono_exception_from_name_two_strings (MonoImage *image, const char *name_space, return (MonoException *) o; } +/** + * mono_exception_from_name_two_strings: + * @image: the Mono image where to look for the class + * @name_space: the namespace for the class + * @name: class name + * @a1: first string argument to pass + * @a2: second string argument to pass + * + * Creates an exception from a constructor that takes two string + * arguments. + * + * Returns: the initialized exception instance. + */ +MonoException * +mono_exception_from_name_two_strings (MonoImage *image, const char *name_space, + const char *name, MonoString *a1, MonoString *a2) +{ + MonoClass *klass = mono_class_from_name (image, name_space, name); + + return create_exception_two_strings (klass, a1, a2); +} + /** * mono_exception_from_name_msg: * @image: the Mono image where to look for the class @@ -150,11 +177,31 @@ mono_exception_from_name_msg (MonoImage *image, const char *name_space, ex = mono_exception_from_name (image, name_space, name); if (msg) - ex->message = mono_string_new (mono_object_get_domain ((MonoObject*)ex), msg); + MONO_OBJECT_SETREF (ex, message, mono_string_new (mono_object_get_domain ((MonoObject*)ex), msg)); return ex; } +/** + * mono_exception_from_token_two_strings: + * + * Same as mono_exception_from_name_two_strings, but lookup the exception class using + * IMAGE and TOKEN. + */ +MonoException * +mono_exception_from_token_two_strings (MonoImage *image, guint32 token, + MonoString *a1, MonoString *a2) +{ + MonoClass *klass = mono_class_get (image, token); + + return create_exception_two_strings (klass, a1, a2); +} + +/** + * mono_get_exception_divide_by_zero: + * + * Returns: a new instance of the System.DivideByZeroException + */ MonoException * mono_get_exception_divide_by_zero () { @@ -162,6 +209,11 @@ mono_get_exception_divide_by_zero () "DivideByZeroException"); } +/** + * mono_get_exception_security: + * + * Returns: a new instance of the System.Security.SecurityException + */ MonoException * mono_get_exception_security () { @@ -169,6 +221,11 @@ mono_get_exception_security () "SecurityException"); } +/** + * mono_get_exception_thread_abort: + * + * Returns: a new instance of the System.Threading.ThreadAbortException. + */ MonoException * mono_get_exception_thread_abort () { @@ -176,6 +233,23 @@ mono_get_exception_thread_abort () "ThreadAbortException"); } +/** + * mono_get_exception_thread_interrupted: + * + * Returns: a new instance of the System.Threading.ThreadInterruptedException. + */ +MonoException * +mono_get_exception_thread_interrupted () +{ + return mono_exception_from_name (mono_get_corlib (), "System.Threading", + "ThreadInterruptedException"); +} + +/** + * mono_get_exception_arithmetic: + * + * Returns: a new instance of the System.ArithmeticException. + */ MonoException * mono_get_exception_arithmetic () { @@ -183,6 +257,11 @@ mono_get_exception_arithmetic () "ArithmeticException"); } +/** + * mono_get_exception_overflow: + * + * Returns: a new instance of the System.OverflowException + */ MonoException * mono_get_exception_overflow () { @@ -190,6 +269,11 @@ mono_get_exception_overflow () "OverflowException"); } +/** + * mono_get_exception_null_reference: + * + * Returns: a new instance of the System.NullReferenceException + */ MonoException * mono_get_exception_null_reference () { @@ -197,27 +281,47 @@ mono_get_exception_null_reference () "NullReferenceException"); } +/** + * mono_get_exception_execution_engine: + * @msg: the message to pass to the user + * + * Returns: a new instance of the System.ExecutionEngineException + */ MonoException * mono_get_exception_execution_engine (const char *msg) { - return mono_exception_from_name_msg (mono_get_corlib (), "System", - "ExecutionEngineException", msg); + return mono_exception_from_name_msg (mono_get_corlib (), "System", "ExecutionEngineException", msg); } +/** + * mono_get_exception_serialization: + * @msg: the message to pass to the user + * + * Returns: a new instance of the System.Runtime.Serialization.SerializationException + */ MonoException * mono_get_exception_serialization (const char *msg) { - return mono_exception_from_name_msg (mono_get_corlib (), "System.Runtime.Serialization", - "SerializationException", msg); + return mono_exception_from_name_msg (mono_get_corlib (), "System.Runtime.Serialization", "SerializationException", msg); } +/** + * mono_get_exception_invalid_cast: + * + * Returns: a new instance of the System.InvalidCastException + */ MonoException * mono_get_exception_invalid_cast () { - return mono_exception_from_name (mono_get_corlib (), "System", - "InvalidCastException"); + return mono_exception_from_name (mono_get_corlib (), "System", "InvalidCastException"); } +/** + * mono_get_exception_invalid_operation: + * @msg: the message to pass to the user + * + * Returns: a new instance of the System.InvalidOperationException + */ MonoException * mono_get_exception_invalid_operation (const char *msg) { @@ -225,6 +329,11 @@ mono_get_exception_invalid_operation (const char *msg) "InvalidOperationException", msg); } +/** + * mono_get_exception_index_out_of_range: + * + * Returns: a new instance of the System.IndexOutOfRangeException + */ MonoException * mono_get_exception_index_out_of_range () { @@ -232,6 +341,11 @@ mono_get_exception_index_out_of_range () "IndexOutOfRangeException"); } +/** + * mono_get_exception_array_type_mismatch: + * + * Returns: a new instance of the System.ArrayTypeMismatchException + */ MonoException * mono_get_exception_array_type_mismatch () { @@ -239,40 +353,86 @@ mono_get_exception_array_type_mismatch () "ArrayTypeMismatchException"); } +/** + * mono_get_exception_type_load: + * @class_name: the name of the class that could not be loaded + * @assembly_name: the assembly where the class was looked up. + * + * Returns: a new instance of the System.TypeLoadException. + */ MonoException * -mono_get_exception_type_load (MonoString *type_name) +mono_get_exception_type_load (MonoString *class_name, char *assembly_name) { - MonoTypeLoadException *exc; - - exc = (MonoTypeLoadException *) mono_exception_from_name (mono_get_corlib (), - "System", - "TypeLoadException"); + MonoString *s = assembly_name ? mono_string_new (mono_domain_get (), assembly_name) : mono_string_new (mono_domain_get (), ""); - exc->type_name = type_name; - return (MonoException *) exc; + return mono_exception_from_name_two_strings (mono_get_corlib (), "System", + "TypeLoadException", class_name, s); } +/** + * mono_get_exception_not_implemented: + * @msg: the message to pass to the user + * + * Returns: a new instance of the System.NotImplementedException + */ MonoException * mono_get_exception_not_implemented (const char *msg) { - MonoException *ex; - - ex = mono_exception_from_name (mono_get_corlib (), "System", - "NotImplementedException"); + return mono_exception_from_name_msg (mono_get_corlib (), "System", "NotImplementedException", msg); +} - if (msg) - ex->message = mono_string_new (mono_object_get_domain ((MonoObject*)ex), msg); +/** + * mono_get_exception_not_supported: + * @msg: the message to pass to the user + * + * Returns: a new instance of the System.NotSupportedException + */ +MonoException * +mono_get_exception_not_supported (const char *msg) +{ + return mono_exception_from_name_msg (mono_get_corlib (), "System", "NotSupportedException", msg); +} - return ex; +/** + * mono_get_exception_missing_method: + * @class_name: the class where the lookup was performed. + * @member_name: the name of the missing method. + * + * Returns: a new instance of the System.MissingMethodException + */ +MonoException * +mono_get_exception_missing_method (const char *class_name, const char *member_name) +{ + MonoString *s1 = mono_string_new (mono_domain_get (), class_name); + MonoString *s2 = mono_string_new (mono_domain_get (), member_name); + + return mono_exception_from_name_two_strings (mono_get_corlib (), "System", + "MissingMethodException", s1, s2); } +/** + * mono_get_exception_missing_field: + * @class_name: the class where the lookup was performed + * @member_name: the name of the missing method. + * + * Returns: a new instance of the System.MissingFieldException + */ MonoException * -mono_get_exception_missing_method () +mono_get_exception_missing_field (const char *class_name, const char *member_name) { - return mono_exception_from_name (mono_get_corlib (), "System", - "MissingMethodException"); + MonoString *s1 = mono_string_new (mono_domain_get (), class_name); + MonoString *s2 = mono_string_new (mono_domain_get (), member_name); + + return mono_exception_from_name_two_strings (mono_get_corlib (), "System", + "MissingFieldException", s1, s2); } +/** + * mono_get_exception_argument_null: + * @arg: the name of the argument that is null + * + * Returns: a new instance of the System.ArgumentNullException + */ MonoException* mono_get_exception_argument_null (const char *arg) { @@ -281,13 +441,20 @@ mono_get_exception_argument_null (const char *arg) ex = mono_exception_from_name ( mono_get_corlib (), "System", "ArgumentNullException"); - if (arg) - ((MonoArgumentException *)ex)->param_name = - mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg); + if (arg) { + MonoArgumentException *argex = (MonoArgumentException *)ex; + MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg)); + } return ex; } +/** + * mono_get_exception_argument: + * @arg: the name of the invalid argument. + * + * Returns: a new instance of the System.ArgumentException + */ MonoException * mono_get_exception_argument (const char *arg, const char *msg) { @@ -296,13 +463,20 @@ mono_get_exception_argument (const char *arg, const char *msg) ex = mono_exception_from_name_msg ( mono_get_corlib (), "System", "ArgumentException", msg); - if (arg) - ((MonoArgumentException *)ex)->param_name = - mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg); + if (arg) { + MonoArgumentException *argex = (MonoArgumentException *)ex; + MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg)); + } return ex; } +/** + * mono_get_exception_argument_out_of_range: + * @arg: the name of the out of range argument. + * + * Returns: a new instance of the System.ArgumentOutOfRangeException + */ MonoException * mono_get_exception_argument_out_of_range (const char *arg) { @@ -311,13 +485,20 @@ mono_get_exception_argument_out_of_range (const char *arg) ex = mono_exception_from_name ( mono_get_corlib (), "System", "ArgumentOutOfRangeException"); - if (arg) - ((MonoArgumentException *)ex)->param_name = - mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg); + if (arg) { + MonoArgumentException *argex = (MonoArgumentException *)ex; + MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg)); + } return ex; } +/** + * mono_get_exception_thread_state: + * @msg: the message to present to the user + * + * Returns: a new instance of the System.Threading.ThreadStateException + */ MonoException * mono_get_exception_thread_state (const char *msg) { @@ -325,6 +506,12 @@ mono_get_exception_thread_state (const char *msg) mono_get_corlib (), "System.Threading", "ThreadStateException", msg); } +/** + * mono_get_exception_io: + * @msg: the message to present to the user + * + * Returns: a new instance of the System.IO.IOException + */ MonoException * mono_get_exception_io (const char *msg) { @@ -332,6 +519,12 @@ mono_get_exception_io (const char *msg) mono_get_corlib (), "System.IO", "IOException", msg); } +/** + * mono_get_exception_file_not_found: + * @fname: the name of the file not found. + * + * Returns: a new instance of the System.IO.FileNotFoundException + */ MonoException * mono_get_exception_file_not_found (MonoString *fname) { @@ -339,15 +532,29 @@ mono_get_exception_file_not_found (MonoString *fname) mono_get_corlib (), "System.IO", "FileNotFoundException", fname, fname); } +/** + * mono_get_exception_file_not_found2: + * @msg: an informative message for the user. + * @fname: the name of the file not found. + * + * Returns: a new instance of the System.IO.FileNotFoundException + */ MonoException * mono_get_exception_file_not_found2 (const char *msg, MonoString *fname) { - MonoString *s = mono_string_new (mono_domain_get (), msg); + MonoString *s = msg ? mono_string_new (mono_domain_get (), msg) : NULL; return mono_exception_from_name_two_strings ( mono_get_corlib (), "System.IO", "FileNotFoundException", s, fname); } +/** + * mono_get_exception_type_initialization: + * @type_name: the name of the type that failed to initialize. + * @inner: the inner exception. + * + * Returns: a new instance of the System.TypeInitializationException + */ MonoException * mono_get_exception_type_initialization (const gchar *type_name, MonoException *inner) { @@ -381,36 +588,144 @@ mono_get_exception_type_initialization (const gchar *type_name, MonoException *i return (MonoException *) exc; } +/** + * mono_get_exception_synchronization_lock: + * @inner: the inner exception. + * + * Returns: a new instance of the System.SynchronizationLockException + */ MonoException * mono_get_exception_synchronization_lock (const char *msg) { return mono_exception_from_name_msg (mono_get_corlib (), "System.Threading", "SynchronizationLockException", msg); } +/** + * mono_get_exception_cannot_unload_appdomain: + * @inner: the inner exception. + * + * Returns: a new instance of the System.CannotUnloadAppDomainException + */ MonoException * mono_get_exception_cannot_unload_appdomain (const char *msg) { return mono_exception_from_name_msg (mono_get_corlib (), "System", "CannotUnloadAppDomainException", msg); } +/** + * mono_get_exception_appdomain_unloaded + * + * Returns: a new instance of the System.AppDomainUnloadedException + */ MonoException * mono_get_exception_appdomain_unloaded (void) { return mono_exception_from_name (mono_get_corlib (), "System", "AppDomainUnloadedException"); } +/** + * mono_get_exception_bad_image_format: + * @msg: an informative message for the user. + * + * Returns: a new instance of the System.BadImageFormatException + */ MonoException * mono_get_exception_bad_image_format (const char *msg) { return mono_exception_from_name_msg (mono_get_corlib (), "System", "BadImageFormatException", msg); } +/** + * mono_get_exception_bad_image_format2: + * @msg: an informative message for the user. + * @fname: The full name of the file with the invalid image. + * + * Returns: a new instance of the System.BadImageFormatException + */ +MonoException * +mono_get_exception_bad_image_format2 (const char *msg, MonoString *fname) +{ + MonoString *s = msg ? mono_string_new (mono_domain_get (), msg) : NULL; + + return mono_exception_from_name_two_strings ( + mono_get_corlib (), "System", "BadImageFormatException", s, fname); +} + +/** + * mono_get_exception_stack_overflow: + * + * Returns: a new instance of the System.StackOverflowException + */ MonoException * mono_get_exception_stack_overflow (void) { return mono_exception_from_name (mono_get_corlib (), "System", "StackOverflowException"); } +/** + * mono_get_exception_out_of_memory: + * + * Returns: a new instance of the System.OutOfMemoryException + */ +MonoException * +mono_get_exception_out_of_memory (void) +{ + return mono_exception_from_name (mono_get_corlib (), "System", "OutOfMemoryException"); +} + +/** + * mono_get_exception_field_access: + * + * Returns: a new instance of the System.FieldAccessException + */ +MonoException * +mono_get_exception_field_access (void) +{ + return mono_exception_from_name (mono_get_corlib (), "System", "FieldAccessException"); +} + +/** + * mono_get_exception_field_access2: + * @msg: an informative message for the user. + * + * Returns: a new instance of the System.FieldAccessException + */ +MonoException * +mono_get_exception_field_access_msg (const char *msg) +{ + return mono_exception_from_name_msg (mono_get_corlib (), "System", "FieldAccessException", msg); +} + +/** + * mono_get_exception_method_access: + * + * Returns: a new instance of the System.MethodAccessException + */ +MonoException * +mono_get_exception_method_access (void) +{ + return mono_exception_from_name (mono_get_corlib (), "System", "MethodAccessException"); +} + +/** + * mono_get_exception_method_access2: + * @msg: an informative message for the user. + * + * Returns: a new instance of the System.MethodAccessException + */ +MonoException * +mono_get_exception_method_access_msg (const char *msg) +{ + return mono_exception_from_name_msg (mono_get_corlib (), "System", "MethodAccessException", msg); +} + +/** + * mono_get_exception_reflection_type_load: + * @types: an array of types that were defined in the moduled loaded. + * @exceptions: an array of exceptions that were thrown during the type loading. + * + * Returns: a new instance of the System.Reflection.ReflectionTypeLoadException + */ MonoException * mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions) { @@ -434,3 +749,14 @@ mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions return (MonoException *) exc; } + +MonoException * +mono_get_exception_runtime_wrapped (MonoObject *wrapped_exception) +{ + MonoRuntimeWrappedException *ex = (MonoRuntimeWrappedException*) + mono_exception_from_name (mono_get_corlib (), "System.Runtime.CompilerServices", + "RuntimeWrappedException"); + + MONO_OBJECT_SETREF (ex, wrapped_exception, wrapped_exception); + return (MonoException*)ex; +}