mono/metadata/exception.c

   1 /*
   2  * exception.c: Exception handling
   3  *
   4  * Authors:
   5  *      Paolo Molaro    (lupus@ximian.com)
   6  *      Dietmar Maurer  (dietmar@ximian.com)
   7  *      Dick Porter     (dick@ximian.com)
   8  *      Miguel de Icaza (miguel@ximian.com)
   9  *
  10  * (C) 2001, 2002 Ximian, Inc.
  11  */
  12
  13 #include <mono/metadata/exception.h>
  14 #include <mono/metadata/object-internals.h>
  15 #include <mono/metadata/appdomain.h>
  16 #include <string.h>
  17
  18 /**
  19  * mono_exception_from_name:
  20  * @image: the Mono image where to look for the class
  21  * @name_space: the namespace for the class
  22  * @name: class name
  23  *
  24  * Creates an exception of the given namespace/name class in the
  25  * current domain.
  26  *
  27  * Returns: the initialized exception instance.
  28  */
  29 MonoException *
  30 mono_exception_from_name (MonoImage *image, const char *name_space,
  31                           const char *name)
  32 {
  33         return mono_exception_from_name_domain (mono_domain_get (), image, name_space, name);
  34 }
  35
  36 /**
  37  * mono_exception_from_name_domain:
  38  * @domain: Domain where the return object will be created.
  39  * @image: the Mono image where to look for the class
  40  * @name_space: the namespace for the class
  41  * @name: class name
  42  *
  43  * Creates an exception object of the given namespace/name class on
  44  * the given domain.
  45  *
  46  * Returns: the initialized exception instance.
  47  */
  48 MonoException *
  49 mono_exception_from_name_domain (MonoDomain *domain, MonoImage *image,
  50                                  const char* name_space, const char *name)
  51 {
  52         MonoClass *klass;
  53         MonoObject *o;
  54
  55         klass = mono_class_from_name (image, name_space, name);
  56
  57         o = mono_object_new (domain, klass);
  58         g_assert (o != NULL);
  59
  60         mono_runtime_object_init (o);
  61
  62         return (MonoException *)o;
  63 }
  64
  65
  66 /**
  67  * mono_exception_from_token:
  68  * @image: the Mono image where to look for the class
  69  * @token: The type token of the class
  70  *
  71  * Creates an exception of the type given by @token.
  72  *
  73  * Returns: the initialized exception instance.
  74  */
  75 MonoException *
  76 mono_exception_from_token (MonoImage *image, guint32 token)
  77 {
  78         MonoClass *klass;
  79         MonoObject *o;
  80
  81         klass = mono_class_get (image, token);
  82
  83         o = mono_object_new (mono_domain_get (), klass);
  84         g_assert (o != NULL);
  85
  86         mono_runtime_object_init (o);
  87
  88         return (MonoException *)o;
  89 }
  90
  91 /**
  92  * mono_exception_from_name_two_strings:
  93  * @image: the Mono image where to look for the class
  94  * @name_space: the namespace for the class
  95  * @name: class name
  96  * @a1: first string argument to pass
  97  * @a2: second string argument to pass
  98  *
  99  * Creates an exception from a constructor that takes two string
 100  * arguments.
 101  *
 102  * Returns: the initialized exception instance.
 103  */
 104 MonoException *
 105 mono_exception_from_name_two_strings (MonoImage *image, const char *name_space,
 106                                       const char *name, MonoString *a1, MonoString *a2)
 107 {
 108         MonoDomain *domain = mono_domain_get ();
 109         MonoClass *klass;
 110         MonoMethod *method = NULL;
 111         MonoObject *o;
 112         int count = 1;
 113         gpointer args [2];
 114         gpointer iter;
 115         MonoMethod *m;
 116
 117         if (a2 != NULL)
 118                 count++;
 119
 120         klass = mono_class_from_name (image, name_space, name);
 121         o = mono_object_new (domain, klass);
 122
 123         iter = NULL;
 124         while ((m = mono_class_get_methods (klass, &iter))) {
 125                 MonoMethodSignature *sig;
 126
 127                 if (strcmp (".ctor", mono_method_get_name (m)))
 128                         continue;
 129                 sig = mono_method_signature (m);
 130                 if (sig->param_count != count)
 131                         continue;
 132
 133                 if (sig->params [0]->type != MONO_TYPE_STRING)
 134                         continue;
 135                 if (count == 2 && sig->params [1]->type != MONO_TYPE_STRING)
 136                         continue;
 137                 method = m;
 138         }
 139
 140         args [0] = a1;
 141         args [1] = a2;
 142         mono_runtime_invoke (method, o, args, NULL);
 143         return (MonoException *) o;
 144 }
 145
 146 /**
 147  * mono_exception_from_name_msg:
 148  * @image: the Mono image where to look for the class
 149  * @name_space: the namespace for the class
 150  * @name: class name
 151  * @msg: the message to embed inside the exception
 152  *
 153  * Creates an exception and initializes its message field.
 154  *
 155  * Returns: the initialized exception instance.
 156  */
 157 MonoException *
 158 mono_exception_from_name_msg (MonoImage *image, const char *name_space,
 159                               const char *name, const char *msg)
 160 {
 161         MonoException *ex;
 162
 163         ex = mono_exception_from_name (image, name_space, name);
 164
 165         if (msg)
 166                 ex->message = mono_string_new (mono_object_get_domain ((MonoObject*)ex), msg);
 167
 168         return ex;
 169 }
 170
 171 /**
 172  * mono_get_exception_divide_by_zero:
 173  *
 174  * Returns: a new instance of the System.DivideByZeroException
 175  */
 176 MonoException *
 177 mono_get_exception_divide_by_zero ()
 178 {
 179         return mono_exception_from_name (mono_get_corlib (), "System",
 180                                          "DivideByZeroException");
 181 }
 182
 183 /**
 184  * mono_get_exception_security:
 185  *
 186  * Returns: a new instance of the System.Security.SecurityException
 187  */
 188 MonoException *
 189 mono_get_exception_security ()
 190 {
 191         return mono_exception_from_name (mono_get_corlib (), "System.Security",
 192                                          "SecurityException");
 193 }
 194
 195 /**
 196  * mono_get_exception_thread_abort:
 197  *
 198  * Returns: a new instance of the System.Threading.ThreadAbortException.
 199  */
 200 MonoException *
 201 mono_get_exception_thread_abort ()
 202 {
 203         return mono_exception_from_name (mono_get_corlib (), "System.Threading",
 204                                          "ThreadAbortException");
 205 }
 206
 207 /**
 208  * mono_get_exception_arithmetic:
 209  *
 210  * Returns: a new instance of the System.ArithmeticException.
 211  */
 212 MonoException *
 213 mono_get_exception_arithmetic ()
 214 {
 215         return mono_exception_from_name (mono_get_corlib (), "System",
 216                                          "ArithmeticException");
 217 }
 218
 219 /**
 220  * mono_get_exception_overflow:
 221  *
 222  * Returns: a new instance of the System.OverflowException
 223  */
 224 MonoException *
 225 mono_get_exception_overflow ()
 226 {
 227         return mono_exception_from_name (mono_get_corlib (), "System",
 228                                          "OverflowException");
 229 }
 230
 231 /**
 232  * mono_get_exception_null_reference:
 233  *
 234  * Returns: a new instance of the System.NullReferenceException
 235  */
 236 MonoException *
 237 mono_get_exception_null_reference ()
 238 {
 239         return mono_exception_from_name (mono_get_corlib (), "System",
 240                                          "NullReferenceException");
 241 }
 242
 243 /**
 244  * mono_get_exception_execution_engine:
 245  * @msg: the message to pass to the user
 246  *
 247  * Returns: a new instance of the System.ExecutionEngineException
 248  */
 249 MonoException *
 250 mono_get_exception_execution_engine (const char *msg)
 251 {
 252         return mono_exception_from_name_msg (mono_get_corlib (), "System", "ExecutionEngineException", msg);
 253 }
 254
 255 /**
 256  * mono_get_exception_serialization:
 257  * @msg: the message to pass to the user
 258  *
 259  * Returns: a new instance of the System.Runtime.Serialization.SerializationException
 260  */
 261 MonoException *
 262 mono_get_exception_serialization (const char *msg)
 263 {
 264         return mono_exception_from_name_msg (mono_get_corlib (), "System.Runtime.Serialization", "SerializationException", msg);
 265 }
 266
 267 /**
 268  * mono_get_exception_invalid_cast:
 269  *
 270  * Returns: a new instance of the System.InvalidCastException
 271  */
 272 MonoException *
 273 mono_get_exception_invalid_cast ()
 274 {
 275         return mono_exception_from_name (mono_get_corlib (), "System", "InvalidCastException");
 276 }
 277
 278 /**
 279  * mono_get_exception_invalid_operation:
 280  * @msg: the message to pass to the user
 281  *
 282  * Returns: a new instance of the System.InvalidOperationException
 283  */
 284 MonoException *
 285 mono_get_exception_invalid_operation (const char *msg)
 286 {
 287         return mono_exception_from_name_msg (mono_get_corlib (), "System",
 288                                         "InvalidOperationException", msg);
 289 }
 290
 291 /**
 292  * mono_get_exception_index_out_of_range:
 293  *
 294  * Returns: a new instance of the System.IndexOutOfRangeException
 295  */
 296 MonoException *
 297 mono_get_exception_index_out_of_range ()
 298 {
 299         return mono_exception_from_name (mono_get_corlib (), "System",
 300                                          "IndexOutOfRangeException");
 301 }
 302
 303 /**
 304  * mono_get_exception_array_type_mismatch:
 305  *
 306  * Returns: a new instance of the System.ArrayTypeMismatchException
 307  */
 308 MonoException *
 309 mono_get_exception_array_type_mismatch ()
 310 {
 311         return mono_exception_from_name (mono_get_corlib (), "System",
 312                                          "ArrayTypeMismatchException");
 313 }
 314
 315 /**
 316  * mono_get_exception_type_load:
 317  * @class_name: the name of the class that could not be loaded
 318  * @assembly_name: the assembly where the class was looked up.
 319  *
 320  * Returns: a new instance of the System.TypeLoadException.
 321  */
 322 MonoException *
 323 mono_get_exception_type_load (MonoString *class_name, char *assembly_name)
 324 {
 325         MonoString *s = assembly_name ? mono_string_new (mono_domain_get (), assembly_name) : mono_string_new (mono_domain_get (), "");
 326
 327         return mono_exception_from_name_two_strings (mono_get_corlib (), "System",
 328                                                      "TypeLoadException", class_name, s);
 329 }
 330
 331 /**
 332  * mono_get_exception_not_implemented:
 333  * @msg: the message to pass to the user
 334  *
 335  * Returns: a new instance of the System.NotImplementedException
 336  */
 337 MonoException *
 338 mono_get_exception_not_implemented (const char *msg)
 339 {
 340         MonoException *ex;
 341
 342         ex = mono_exception_from_name (mono_get_corlib (), "System",
 343                                        "NotImplementedException");
 344
 345         if (msg)
 346                 ex->message = mono_string_new (mono_object_get_domain ((MonoObject*)ex), msg);
 347
 348         return ex;
 349 }
 350
 351 /**
 352  * mono_get_exception_missing_method:
 353  * @class_name: the class where the lookup was performed.
 354  * @member_name: the name of the missing method.
 355  *
 356  * Returns: a new instance of the System.MissingMethodException
 357  */
 358 MonoException *
 359 mono_get_exception_missing_method (const char *class_name, const char *member_name)
 360 {
 361         MonoString *s1 = mono_string_new (mono_domain_get (), class_name);
 362         MonoString *s2 = mono_string_new (mono_domain_get (), member_name);
 363
 364         return mono_exception_from_name_two_strings (mono_get_corlib (), "System",
 365                                                      "MissingMethodException", s1, s2);
 366 }
 367
 368 /**
 369  * mono_get_exception_missing_field:
 370  * @class_name: the class where the lookup was performed
 371  * @member_name: the name of the missing method.
 372  *
 373  * Returns: a new instance of the System.MissingFieldException
 374  */
 375 MonoException *
 376 mono_get_exception_missing_field (const char *class_name, const char *member_name)
 377 {
 378         MonoString *s1 = mono_string_new (mono_domain_get (), class_name);
 379         MonoString *s2 = mono_string_new (mono_domain_get (), member_name);
 380
 381         return mono_exception_from_name_two_strings (mono_get_corlib (), "System",
 382                                                      "MissingFieldException", s1, s2);
 383 }
 384
 385 /**
 386  * mono_get_exception_argument_null:
 387  * @arg: the name of the argument that is null
 388  *
 389  * Returns: a new instance of the System.ArgumentNullException
 390  */
 391 MonoException*
 392 mono_get_exception_argument_null (const char *arg)
 393 {
 394         MonoException *ex;
 395
 396         ex = mono_exception_from_name (
 397                 mono_get_corlib (), "System", "ArgumentNullException");
 398
 399         if (arg)
 400                 ((MonoArgumentException *)ex)->param_name =
 401                         mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg);
 402
 403         return ex;
 404 }
 405
 406 /**
 407  * mono_get_exception_argument:
 408  * @arg: the name of the invalid argument.
 409  *
 410  * Returns: a new instance of the System.ArgumentException
 411  */
 412 MonoException *
 413 mono_get_exception_argument (const char *arg, const char *msg)
 414 {
 415         MonoException *ex;
 416
 417         ex = mono_exception_from_name_msg (
 418                 mono_get_corlib (), "System", "ArgumentException", msg);
 419
 420         if (arg)
 421                 ((MonoArgumentException *)ex)->param_name =
 422                         mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg);
 423
 424         return ex;
 425 }
 426
 427 /**
 428  * mono_get_exception_argument_out_of_range:
 429  * @arg: the name of the out of range argument.
 430  *
 431  * Returns: a new instance of the System.ArgumentOutOfRangeException
 432  */
 433 MonoException *
 434 mono_get_exception_argument_out_of_range (const char *arg)
 435 {
 436         MonoException *ex;
 437
 438         ex = mono_exception_from_name (
 439                 mono_get_corlib (), "System", "ArgumentOutOfRangeException");
 440
 441         if (arg)
 442                 ((MonoArgumentException *)ex)->param_name =
 443                         mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg);
 444
 445         return ex;
 446 }
 447
 448 /**
 449  * mono_get_exception_thread_state:
 450  * @msg: the message to present to the user
 451  *
 452  * Returns: a new instance of the System.Threading.ThreadStateException
 453  */
 454 MonoException *
 455 mono_get_exception_thread_state (const char *msg)
 456 {
 457         return mono_exception_from_name_msg (
 458                 mono_get_corlib (), "System.Threading", "ThreadStateException", msg);
 459 }
 460
 461 /**
 462  * mono_get_exception_io:
 463  * @msg: the message to present to the user
 464  *
 465  * Returns: a new instance of the System.IO.IOException
 466  */
 467 MonoException *
 468 mono_get_exception_io (const char *msg)
 469 {
 470         return mono_exception_from_name_msg (
 471                 mono_get_corlib (), "System.IO", "IOException", msg);
 472 }
 473
 474 /**
 475  * mono_get_exception_file_not_found:
 476  * @fname: the name of the file not found.
 477  *
 478  * Returns: a new instance of the System.IO.FileNotFoundException
 479  */
 480 MonoException *
 481 mono_get_exception_file_not_found (MonoString *fname)
 482 {
 483         return mono_exception_from_name_two_strings (
 484                 mono_get_corlib (), "System.IO", "FileNotFoundException", fname, fname);
 485 }
 486
 487 /**
 488  * mono_get_exception_file_not_found2:
 489  * @msg: an informative message for the user.
 490  * @fname: the name of the file not found.
 491  *
 492  * Returns: a new instance of the System.IO.FileNotFoundException
 493  */
 494 MonoException *
 495 mono_get_exception_file_not_found2 (const char *msg, MonoString *fname)
 496 {
 497         MonoString *s = mono_string_new (mono_domain_get (), msg);
 498
 499         return mono_exception_from_name_two_strings (
 500                 mono_get_corlib (), "System.IO", "FileNotFoundException", s, fname);
 501 }
 502
 503 /**
 504  * mono_get_exception_type_initialization:
 505  * @type_name: the name of the type that failed to initialize.
 506  * @inner: the inner exception.
 507  *
 508  * Returns: a new instance of the System.TypeInitializationException
 509  */
 510 MonoException *
 511 mono_get_exception_type_initialization (const gchar *type_name, MonoException *inner)
 512 {
 513         MonoClass *klass;
 514         gpointer args [2];
 515         MonoObject *exc;
 516         MonoMethod *method;
 517         gpointer iter;
 518
 519         klass = mono_class_from_name (mono_get_corlib (), "System", "TypeInitializationException");
 520         g_assert (klass);
 521
 522         mono_class_init (klass);
 523
 524         /* TypeInitializationException only has 1 ctor with 2 args */
 525         iter = NULL;
 526         while ((method = mono_class_get_methods (klass, &iter))) {
 527                 if (!strcmp (".ctor", mono_method_get_name (method)) && mono_method_signature (method)->param_count == 2)
 528                         break;
 529                 method = NULL;
 530         }
 531
 532         g_assert (method);
 533
 534         args [0] = mono_string_new (mono_domain_get (), type_name);
 535         args [1] = inner;
 536
 537         exc = mono_object_new (mono_domain_get (), klass);
 538         mono_runtime_invoke (method, exc, args, NULL);
 539
 540         return (MonoException *) exc;
 541 }
 542
 543 /**
 544  * mono_get_exception_synchronization_lock:
 545  * @inner: the inner exception.
 546  *
 547  * Returns: a new instance of the System.TypeInitializationException
 548  */
 549 MonoException *
 550 mono_get_exception_synchronization_lock (const char *msg)
 551 {
 552         return mono_exception_from_name_msg (mono_get_corlib (), "System.Threading", "SynchronizationLockException", msg);
 553 }
 554
 555 /**
 556  * mono_get_exception_cannot_unload_appdomain:
 557  * @inner: the inner exception.
 558  *
 559  * Returns: a new instance of the System.CannotUnloadAppDomainException
 560  */
 561 MonoException *
 562 mono_get_exception_cannot_unload_appdomain (const char *msg)
 563 {
 564         return mono_exception_from_name_msg (mono_get_corlib (), "System", "CannotUnloadAppDomainException", msg);
 565 }
 566
 567 /**
 568  * mono_get_exception_appdomain_unloaded
 569  *
 570  * Returns: a new instance of the System.AppDomainUnloadedException
 571  */
 572 MonoException *
 573 mono_get_exception_appdomain_unloaded (void)
 574 {
 575         return mono_exception_from_name (mono_get_corlib (), "System", "AppDomainUnloadedException");
 576 }
 577
 578 /**
 579  * mono_get_exception_bad_image_format:
 580  * @msg: an informative message for the user.
 581  *
 582  * Returns: a new instance of the System.BadImageFormatException
 583  */
 584 MonoException *
 585 mono_get_exception_bad_image_format (const char *msg)
 586 {
 587         return mono_exception_from_name_msg (mono_get_corlib (), "System", "BadImageFormatException", msg);
 588 }
 589
 590 /**
 591  * mono_get_exception_stack_overflow:
 592  *
 593  * Returns: a new instance of the System.StackOverflowException
 594  */
 595 MonoException *
 596 mono_get_exception_stack_overflow (void)
 597 {
 598         return mono_exception_from_name (mono_get_corlib (), "System", "StackOverflowException");
 599 }
 600
 601 /**
 602  * mono_get_exception_reflection_type_load:
 603  * @types: an array of types that were defined in the moduled loaded.
 604  * @exceptions: an array of exceptions that were thrown during the type loading.
 605  *
 606  * Returns: a new instance of the System.Reflection.ReflectionTypeLoadException
 607  */
 608 MonoException *
 609 mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions)
 610 {
 611         MonoClass *klass;
 612         gpointer args [2];
 613         MonoObject *exc;
 614         MonoMethod *method;
 615
 616         klass = mono_class_from_name (mono_get_corlib (), "System.Reflection", "ReflectionTypeLoadException");
 617         g_assert (klass);
 618         mono_class_init (klass);
 619
 620         method = mono_class_get_method_from_name (klass, ".ctor", 2);
 621         g_assert (method);
 622
 623         args [0] = types;
 624         args [1] = exceptions;
 625
 626         exc = mono_object_new (mono_domain_get (), klass);
 627         mono_runtime_invoke (method, exc, args, NULL);
 628
 629         return (MonoException *) exc;
 630 }