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_thread_interrupted:
 209  *
 210  * Returns: a new instance of the System.Threading.ThreadInterruptedException.
 211  */
 212 MonoException *
 213 mono_get_exception_thread_interrupted ()
 214 {
 215         return mono_exception_from_name (mono_get_corlib (), "System.Threading",
 216                                          "ThreadInterruptedException");
 217 }
 218
 219 /**
 220  * mono_get_exception_arithmetic:
 221  *
 222  * Returns: a new instance of the System.ArithmeticException.
 223  */
 224 MonoException *
 225 mono_get_exception_arithmetic ()
 226 {
 227         return mono_exception_from_name (mono_get_corlib (), "System",
 228                                          "ArithmeticException");
 229 }
 230
 231 /**
 232  * mono_get_exception_overflow:
 233  *
 234  * Returns: a new instance of the System.OverflowException
 235  */
 236 MonoException *
 237 mono_get_exception_overflow ()
 238 {
 239         return mono_exception_from_name (mono_get_corlib (), "System",
 240                                          "OverflowException");
 241 }
 242
 243 /**
 244  * mono_get_exception_null_reference:
 245  *
 246  * Returns: a new instance of the System.NullReferenceException
 247  */
 248 MonoException *
 249 mono_get_exception_null_reference ()
 250 {
 251         return mono_exception_from_name (mono_get_corlib (), "System",
 252                                          "NullReferenceException");
 253 }
 254
 255 /**
 256  * mono_get_exception_execution_engine:
 257  * @msg: the message to pass to the user
 258  *
 259  * Returns: a new instance of the System.ExecutionEngineException
 260  */
 261 MonoException *
 262 mono_get_exception_execution_engine (const char *msg)
 263 {
 264         return mono_exception_from_name_msg (mono_get_corlib (), "System", "ExecutionEngineException", msg);
 265 }
 266
 267 /**
 268  * mono_get_exception_serialization:
 269  * @msg: the message to pass to the user
 270  *
 271  * Returns: a new instance of the System.Runtime.Serialization.SerializationException
 272  */
 273 MonoException *
 274 mono_get_exception_serialization (const char *msg)
 275 {
 276         return mono_exception_from_name_msg (mono_get_corlib (), "System.Runtime.Serialization", "SerializationException", msg);
 277 }
 278
 279 /**
 280  * mono_get_exception_invalid_cast:
 281  *
 282  * Returns: a new instance of the System.InvalidCastException
 283  */
 284 MonoException *
 285 mono_get_exception_invalid_cast ()
 286 {
 287         return mono_exception_from_name (mono_get_corlib (), "System", "InvalidCastException");
 288 }
 289
 290 /**
 291  * mono_get_exception_invalid_operation:
 292  * @msg: the message to pass to the user
 293  *
 294  * Returns: a new instance of the System.InvalidOperationException
 295  */
 296 MonoException *
 297 mono_get_exception_invalid_operation (const char *msg)
 298 {
 299         return mono_exception_from_name_msg (mono_get_corlib (), "System",
 300                                         "InvalidOperationException", msg);
 301 }
 302
 303 /**
 304  * mono_get_exception_index_out_of_range:
 305  *
 306  * Returns: a new instance of the System.IndexOutOfRangeException
 307  */
 308 MonoException *
 309 mono_get_exception_index_out_of_range ()
 310 {
 311         return mono_exception_from_name (mono_get_corlib (), "System",
 312                                          "IndexOutOfRangeException");
 313 }
 314
 315 /**
 316  * mono_get_exception_array_type_mismatch:
 317  *
 318  * Returns: a new instance of the System.ArrayTypeMismatchException
 319  */
 320 MonoException *
 321 mono_get_exception_array_type_mismatch ()
 322 {
 323         return mono_exception_from_name (mono_get_corlib (), "System",
 324                                          "ArrayTypeMismatchException");
 325 }
 326
 327 /**
 328  * mono_get_exception_type_load:
 329  * @class_name: the name of the class that could not be loaded
 330  * @assembly_name: the assembly where the class was looked up.
 331  *
 332  * Returns: a new instance of the System.TypeLoadException.
 333  */
 334 MonoException *
 335 mono_get_exception_type_load (MonoString *class_name, char *assembly_name)
 336 {
 337         MonoString *s = assembly_name ? mono_string_new (mono_domain_get (), assembly_name) : mono_string_new (mono_domain_get (), "");
 338
 339         return mono_exception_from_name_two_strings (mono_get_corlib (), "System",
 340                                                      "TypeLoadException", class_name, s);
 341 }
 342
 343 /**
 344  * mono_get_exception_not_implemented:
 345  * @msg: the message to pass to the user
 346  *
 347  * Returns: a new instance of the System.NotImplementedException
 348  */
 349 MonoException *
 350 mono_get_exception_not_implemented (const char *msg)
 351 {
 352         return mono_exception_from_name_msg (mono_get_corlib (), "System", "NotImplementedException", msg);
 353 }
 354
 355 /**
 356  * mono_get_exception_not_supported:
 357  * @msg: the message to pass to the user
 358  *
 359  * Returns: a new instance of the System.NotSupportedException
 360  */
 361 MonoException *
 362 mono_get_exception_not_supported (const char *msg)
 363 {
 364         return mono_exception_from_name_msg (mono_get_corlib (), "System", "NotSupportedException", msg);
 365 }
 366
 367 /**
 368  * mono_get_exception_missing_method:
 369  * @class_name: the class where the lookup was performed.
 370  * @member_name: the name of the missing method.
 371  *
 372  * Returns: a new instance of the System.MissingMethodException
 373  */
 374 MonoException *
 375 mono_get_exception_missing_method (const char *class_name, const char *member_name)
 376 {
 377         MonoString *s1 = mono_string_new (mono_domain_get (), class_name);
 378         MonoString *s2 = mono_string_new (mono_domain_get (), member_name);
 379
 380         return mono_exception_from_name_two_strings (mono_get_corlib (), "System",
 381                                                      "MissingMethodException", s1, s2);
 382 }
 383
 384 /**
 385  * mono_get_exception_missing_field:
 386  * @class_name: the class where the lookup was performed
 387  * @member_name: the name of the missing method.
 388  *
 389  * Returns: a new instance of the System.MissingFieldException
 390  */
 391 MonoException *
 392 mono_get_exception_missing_field (const char *class_name, const char *member_name)
 393 {
 394         MonoString *s1 = mono_string_new (mono_domain_get (), class_name);
 395         MonoString *s2 = mono_string_new (mono_domain_get (), member_name);
 396
 397         return mono_exception_from_name_two_strings (mono_get_corlib (), "System",
 398                                                      "MissingFieldException", s1, s2);
 399 }
 400
 401 /**
 402  * mono_get_exception_argument_null:
 403  * @arg: the name of the argument that is null
 404  *
 405  * Returns: a new instance of the System.ArgumentNullException
 406  */
 407 MonoException*
 408 mono_get_exception_argument_null (const char *arg)
 409 {
 410         MonoException *ex;
 411
 412         ex = mono_exception_from_name (
 413                 mono_get_corlib (), "System", "ArgumentNullException");
 414
 415         if (arg) {
 416                 MonoArgumentException *argex = (MonoArgumentException *)ex;
 417                 MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg));
 418         }
 419
 420         return ex;
 421 }
 422
 423 /**
 424  * mono_get_exception_argument:
 425  * @arg: the name of the invalid argument.
 426  *
 427  * Returns: a new instance of the System.ArgumentException
 428  */
 429 MonoException *
 430 mono_get_exception_argument (const char *arg, const char *msg)
 431 {
 432         MonoException *ex;
 433
 434         ex = mono_exception_from_name_msg (
 435                 mono_get_corlib (), "System", "ArgumentException", msg);
 436
 437         if (arg) {
 438                 MonoArgumentException *argex = (MonoArgumentException *)ex;
 439                 MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg));
 440         }
 441
 442         return ex;
 443 }
 444
 445 /**
 446  * mono_get_exception_argument_out_of_range:
 447  * @arg: the name of the out of range argument.
 448  *
 449  * Returns: a new instance of the System.ArgumentOutOfRangeException
 450  */
 451 MonoException *
 452 mono_get_exception_argument_out_of_range (const char *arg)
 453 {
 454         MonoException *ex;
 455
 456         ex = mono_exception_from_name (
 457                 mono_get_corlib (), "System", "ArgumentOutOfRangeException");
 458
 459         if (arg) {
 460                 MonoArgumentException *argex = (MonoArgumentException *)ex;
 461                 MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg));
 462         }
 463
 464         return ex;
 465 }
 466
 467 /**
 468  * mono_get_exception_thread_state:
 469  * @msg: the message to present to the user
 470  *
 471  * Returns: a new instance of the System.Threading.ThreadStateException
 472  */
 473 MonoException *
 474 mono_get_exception_thread_state (const char *msg)
 475 {
 476         return mono_exception_from_name_msg (
 477                 mono_get_corlib (), "System.Threading", "ThreadStateException", msg);
 478 }
 479
 480 /**
 481  * mono_get_exception_io:
 482  * @msg: the message to present to the user
 483  *
 484  * Returns: a new instance of the System.IO.IOException
 485  */
 486 MonoException *
 487 mono_get_exception_io (const char *msg)
 488 {
 489         return mono_exception_from_name_msg (
 490                 mono_get_corlib (), "System.IO", "IOException", msg);
 491 }
 492
 493 /**
 494  * mono_get_exception_file_not_found:
 495  * @fname: the name of the file not found.
 496  *
 497  * Returns: a new instance of the System.IO.FileNotFoundException
 498  */
 499 MonoException *
 500 mono_get_exception_file_not_found (MonoString *fname)
 501 {
 502         return mono_exception_from_name_two_strings (
 503                 mono_get_corlib (), "System.IO", "FileNotFoundException", fname, fname);
 504 }
 505
 506 /**
 507  * mono_get_exception_file_not_found2:
 508  * @msg: an informative message for the user.
 509  * @fname: the name of the file not found.
 510  *
 511  * Returns: a new instance of the System.IO.FileNotFoundException
 512  */
 513 MonoException *
 514 mono_get_exception_file_not_found2 (const char *msg, MonoString *fname)
 515 {
 516         MonoString *s = msg ? mono_string_new (mono_domain_get (), msg) : NULL;
 517
 518         return mono_exception_from_name_two_strings (
 519                 mono_get_corlib (), "System.IO", "FileNotFoundException", s, fname);
 520 }
 521
 522 /**
 523  * mono_get_exception_type_initialization:
 524  * @type_name: the name of the type that failed to initialize.
 525  * @inner: the inner exception.
 526  *
 527  * Returns: a new instance of the System.TypeInitializationException
 528  */
 529 MonoException *
 530 mono_get_exception_type_initialization (const gchar *type_name, MonoException *inner)
 531 {
 532         MonoClass *klass;
 533         gpointer args [2];
 534         MonoObject *exc;
 535         MonoMethod *method;
 536         gpointer iter;
 537
 538         klass = mono_class_from_name (mono_get_corlib (), "System", "TypeInitializationException");
 539         g_assert (klass);
 540
 541         mono_class_init (klass);
 542
 543         /* TypeInitializationException only has 1 ctor with 2 args */
 544         iter = NULL;
 545         while ((method = mono_class_get_methods (klass, &iter))) {
 546                 if (!strcmp (".ctor", mono_method_get_name (method)) && mono_method_signature (method)->param_count == 2)
 547                         break;
 548                 method = NULL;
 549         }
 550
 551         g_assert (method);
 552
 553         args [0] = mono_string_new (mono_domain_get (), type_name);
 554         args [1] = inner;
 555
 556         exc = mono_object_new (mono_domain_get (), klass);
 557         mono_runtime_invoke (method, exc, args, NULL);
 558
 559         return (MonoException *) exc;
 560 }
 561
 562 /**
 563  * mono_get_exception_synchronization_lock:
 564  * @inner: the inner exception.
 565  *
 566  * Returns: a new instance of the System.TypeInitializationException
 567  */
 568 MonoException *
 569 mono_get_exception_synchronization_lock (const char *msg)
 570 {
 571         return mono_exception_from_name_msg (mono_get_corlib (), "System.Threading", "SynchronizationLockException", msg);
 572 }
 573
 574 /**
 575  * mono_get_exception_cannot_unload_appdomain:
 576  * @inner: the inner exception.
 577  *
 578  * Returns: a new instance of the System.CannotUnloadAppDomainException
 579  */
 580 MonoException *
 581 mono_get_exception_cannot_unload_appdomain (const char *msg)
 582 {
 583         return mono_exception_from_name_msg (mono_get_corlib (), "System", "CannotUnloadAppDomainException", msg);
 584 }
 585
 586 /**
 587  * mono_get_exception_appdomain_unloaded
 588  *
 589  * Returns: a new instance of the System.AppDomainUnloadedException
 590  */
 591 MonoException *
 592 mono_get_exception_appdomain_unloaded (void)
 593 {
 594         return mono_exception_from_name (mono_get_corlib (), "System", "AppDomainUnloadedException");
 595 }
 596
 597 /**
 598  * mono_get_exception_bad_image_format:
 599  * @msg: an informative message for the user.
 600  *
 601  * Returns: a new instance of the System.BadImageFormatException
 602  */
 603 MonoException *
 604 mono_get_exception_bad_image_format (const char *msg)
 605 {
 606         return mono_exception_from_name_msg (mono_get_corlib (), "System", "BadImageFormatException", msg);
 607 }
 608
 609 /**
 610  * mono_get_exception_bad_image_format2:
 611  * @msg: an informative message for the user.
 612  * @fname: The full name of the file with the invalid image.
 613  *
 614  * Returns: a new instance of the System.BadImageFormatException
 615  */
 616 MonoException *
 617 mono_get_exception_bad_image_format2 (const char *msg, MonoString *fname)
 618 {
 619         MonoString *s = msg ? mono_string_new (mono_domain_get (), msg) : NULL;
 620
 621         return mono_exception_from_name_two_strings (
 622                 mono_get_corlib (), "System", "BadImageFormatException", s, fname);
 623 }
 624
 625 /**
 626  * mono_get_exception_stack_overflow:
 627  *
 628  * Returns: a new instance of the System.StackOverflowException
 629  */
 630 MonoException *
 631 mono_get_exception_stack_overflow (void)
 632 {
 633         return mono_exception_from_name (mono_get_corlib (), "System", "StackOverflowException");
 634 }
 635
 636 /**
 637  * mono_get_exception_reflection_type_load:
 638  * @types: an array of types that were defined in the moduled loaded.
 639  * @exceptions: an array of exceptions that were thrown during the type loading.
 640  *
 641  * Returns: a new instance of the System.Reflection.ReflectionTypeLoadException
 642  */
 643 MonoException *
 644 mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions)
 645 {
 646         MonoClass *klass;
 647         gpointer args [2];
 648         MonoObject *exc;
 649         MonoMethod *method;
 650
 651         klass = mono_class_from_name (mono_get_corlib (), "System.Reflection", "ReflectionTypeLoadException");
 652         g_assert (klass);
 653         mono_class_init (klass);
 654
 655         method = mono_class_get_method_from_name (klass, ".ctor", 2);
 656         g_assert (method);
 657
 658         args [0] = types;
 659         args [1] = exceptions;
 660
 661         exc = mono_object_new (mono_domain_get (), klass);
 662         mono_runtime_invoke (method, exc, args, NULL);
 663
 664         return (MonoException *) exc;
 665 }