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                 MONO_OBJECT_SETREF (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         return mono_exception_from_name_msg (mono_get_corlib (), "System", "NotImplementedException", msg);
 341 }
 342
 343 /**
 344  * mono_get_exception_not_supported:
 345  * @msg: the message to pass to the user
 346  *
 347  * Returns: a new instance of the System.NotSupportedException
 348  */
 349 MonoException *
 350 mono_get_exception_not_supported (const char *msg)
 351 {
 352         return mono_exception_from_name_msg (mono_get_corlib (), "System", "NotSupportedException", msg);
 353 }
 354
 355 /**
 356  * mono_get_exception_missing_method:
 357  * @class_name: the class where the lookup was performed.
 358  * @member_name: the name of the missing method.
 359  *
 360  * Returns: a new instance of the System.MissingMethodException
 361  */
 362 MonoException *
 363 mono_get_exception_missing_method (const char *class_name, const char *member_name)
 364 {
 365         MonoString *s1 = mono_string_new (mono_domain_get (), class_name);
 366         MonoString *s2 = mono_string_new (mono_domain_get (), member_name);
 367
 368         return mono_exception_from_name_two_strings (mono_get_corlib (), "System",
 369                                                      "MissingMethodException", s1, s2);
 370 }
 371
 372 /**
 373  * mono_get_exception_missing_field:
 374  * @class_name: the class where the lookup was performed
 375  * @member_name: the name of the missing method.
 376  *
 377  * Returns: a new instance of the System.MissingFieldException
 378  */
 379 MonoException *
 380 mono_get_exception_missing_field (const char *class_name, const char *member_name)
 381 {
 382         MonoString *s1 = mono_string_new (mono_domain_get (), class_name);
 383         MonoString *s2 = mono_string_new (mono_domain_get (), member_name);
 384
 385         return mono_exception_from_name_two_strings (mono_get_corlib (), "System",
 386                                                      "MissingFieldException", s1, s2);
 387 }
 388
 389 /**
 390  * mono_get_exception_argument_null:
 391  * @arg: the name of the argument that is null
 392  *
 393  * Returns: a new instance of the System.ArgumentNullException
 394  */
 395 MonoException*
 396 mono_get_exception_argument_null (const char *arg)
 397 {
 398         MonoException *ex;
 399
 400         ex = mono_exception_from_name (
 401                 mono_get_corlib (), "System", "ArgumentNullException");
 402
 403         if (arg) {
 404                 MonoArgumentException *argex = (MonoArgumentException *)ex;
 405                 MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg));
 406         }
 407
 408         return ex;
 409 }
 410
 411 /**
 412  * mono_get_exception_argument:
 413  * @arg: the name of the invalid argument.
 414  *
 415  * Returns: a new instance of the System.ArgumentException
 416  */
 417 MonoException *
 418 mono_get_exception_argument (const char *arg, const char *msg)
 419 {
 420         MonoException *ex;
 421
 422         ex = mono_exception_from_name_msg (
 423                 mono_get_corlib (), "System", "ArgumentException", msg);
 424
 425         if (arg) {
 426                 MonoArgumentException *argex = (MonoArgumentException *)ex;
 427                 MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg));
 428         }
 429
 430         return ex;
 431 }
 432
 433 /**
 434  * mono_get_exception_argument_out_of_range:
 435  * @arg: the name of the out of range argument.
 436  *
 437  * Returns: a new instance of the System.ArgumentOutOfRangeException
 438  */
 439 MonoException *
 440 mono_get_exception_argument_out_of_range (const char *arg)
 441 {
 442         MonoException *ex;
 443
 444         ex = mono_exception_from_name (
 445                 mono_get_corlib (), "System", "ArgumentOutOfRangeException");
 446
 447         if (arg) {
 448                 MonoArgumentException *argex = (MonoArgumentException *)ex;
 449                 MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg));
 450         }
 451
 452         return ex;
 453 }
 454
 455 /**
 456  * mono_get_exception_thread_state:
 457  * @msg: the message to present to the user
 458  *
 459  * Returns: a new instance of the System.Threading.ThreadStateException
 460  */
 461 MonoException *
 462 mono_get_exception_thread_state (const char *msg)
 463 {
 464         return mono_exception_from_name_msg (
 465                 mono_get_corlib (), "System.Threading", "ThreadStateException", msg);
 466 }
 467
 468 /**
 469  * mono_get_exception_io:
 470  * @msg: the message to present to the user
 471  *
 472  * Returns: a new instance of the System.IO.IOException
 473  */
 474 MonoException *
 475 mono_get_exception_io (const char *msg)
 476 {
 477         return mono_exception_from_name_msg (
 478                 mono_get_corlib (), "System.IO", "IOException", msg);
 479 }
 480
 481 /**
 482  * mono_get_exception_file_not_found:
 483  * @fname: the name of the file not found.
 484  *
 485  * Returns: a new instance of the System.IO.FileNotFoundException
 486  */
 487 MonoException *
 488 mono_get_exception_file_not_found (MonoString *fname)
 489 {
 490         return mono_exception_from_name_two_strings (
 491                 mono_get_corlib (), "System.IO", "FileNotFoundException", fname, fname);
 492 }
 493
 494 /**
 495  * mono_get_exception_file_not_found2:
 496  * @msg: an informative message for the user.
 497  * @fname: the name of the file not found.
 498  *
 499  * Returns: a new instance of the System.IO.FileNotFoundException
 500  */
 501 MonoException *
 502 mono_get_exception_file_not_found2 (const char *msg, MonoString *fname)
 503 {
 504         MonoString *s = mono_string_new (mono_domain_get (), msg);
 505
 506         return mono_exception_from_name_two_strings (
 507                 mono_get_corlib (), "System.IO", "FileNotFoundException", s, fname);
 508 }
 509
 510 /**
 511  * mono_get_exception_type_initialization:
 512  * @type_name: the name of the type that failed to initialize.
 513  * @inner: the inner exception.
 514  *
 515  * Returns: a new instance of the System.TypeInitializationException
 516  */
 517 MonoException *
 518 mono_get_exception_type_initialization (const gchar *type_name, MonoException *inner)
 519 {
 520         MonoClass *klass;
 521         gpointer args [2];
 522         MonoObject *exc;
 523         MonoMethod *method;
 524         gpointer iter;
 525
 526         klass = mono_class_from_name (mono_get_corlib (), "System", "TypeInitializationException");
 527         g_assert (klass);
 528
 529         mono_class_init (klass);
 530
 531         /* TypeInitializationException only has 1 ctor with 2 args */
 532         iter = NULL;
 533         while ((method = mono_class_get_methods (klass, &iter))) {
 534                 if (!strcmp (".ctor", mono_method_get_name (method)) && mono_method_signature (method)->param_count == 2)
 535                         break;
 536                 method = NULL;
 537         }
 538
 539         g_assert (method);
 540
 541         args [0] = mono_string_new (mono_domain_get (), type_name);
 542         args [1] = inner;
 543
 544         exc = mono_object_new (mono_domain_get (), klass);
 545         mono_runtime_invoke (method, exc, args, NULL);
 546
 547         return (MonoException *) exc;
 548 }
 549
 550 /**
 551  * mono_get_exception_synchronization_lock:
 552  * @inner: the inner exception.
 553  *
 554  * Returns: a new instance of the System.TypeInitializationException
 555  */
 556 MonoException *
 557 mono_get_exception_synchronization_lock (const char *msg)
 558 {
 559         return mono_exception_from_name_msg (mono_get_corlib (), "System.Threading", "SynchronizationLockException", msg);
 560 }
 561
 562 /**
 563  * mono_get_exception_cannot_unload_appdomain:
 564  * @inner: the inner exception.
 565  *
 566  * Returns: a new instance of the System.CannotUnloadAppDomainException
 567  */
 568 MonoException *
 569 mono_get_exception_cannot_unload_appdomain (const char *msg)
 570 {
 571         return mono_exception_from_name_msg (mono_get_corlib (), "System", "CannotUnloadAppDomainException", msg);
 572 }
 573
 574 /**
 575  * mono_get_exception_appdomain_unloaded
 576  *
 577  * Returns: a new instance of the System.AppDomainUnloadedException
 578  */
 579 MonoException *
 580 mono_get_exception_appdomain_unloaded (void)
 581 {
 582         return mono_exception_from_name (mono_get_corlib (), "System", "AppDomainUnloadedException");
 583 }
 584
 585 /**
 586  * mono_get_exception_bad_image_format:
 587  * @msg: an informative message for the user.
 588  *
 589  * Returns: a new instance of the System.BadImageFormatException
 590  */
 591 MonoException *
 592 mono_get_exception_bad_image_format (const char *msg)
 593 {
 594         return mono_exception_from_name_msg (mono_get_corlib (), "System", "BadImageFormatException", msg);
 595 }
 596
 597 /**
 598  * mono_get_exception_stack_overflow:
 599  *
 600  * Returns: a new instance of the System.StackOverflowException
 601  */
 602 MonoException *
 603 mono_get_exception_stack_overflow (void)
 604 {
 605         return mono_exception_from_name (mono_get_corlib (), "System", "StackOverflowException");
 606 }
 607
 608 /**
 609  * mono_get_exception_reflection_type_load:
 610  * @types: an array of types that were defined in the moduled loaded.
 611  * @exceptions: an array of exceptions that were thrown during the type loading.
 612  *
 613  * Returns: a new instance of the System.Reflection.ReflectionTypeLoadException
 614  */
 615 MonoException *
 616 mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions)
 617 {
 618         MonoClass *klass;
 619         gpointer args [2];
 620         MonoObject *exc;
 621         MonoMethod *method;
 622
 623         klass = mono_class_from_name (mono_get_corlib (), "System.Reflection", "ReflectionTypeLoadException");
 624         g_assert (klass);
 625         mono_class_init (klass);
 626
 627         method = mono_class_get_method_from_name (klass, ".ctor", 2);
 628         g_assert (method);
 629
 630         args [0] = types;
 631         args [1] = exceptions;
 632
 633         exc = mono_object_new (mono_domain_get (), klass);
 634         mono_runtime_invoke (method, exc, args, NULL);
 635
 636         return (MonoException *) exc;
 637 }