Recent changes to Exceptions

Exceptions modified by Will Pittenger

Will Pittenger — Sun, 16 Feb 2014 10:28:57 -0000

--- v3
+++ v4
@@ -18,6 +18,7 @@
 The **[throws](keywords-throws)** keyword can be applied to any procedure as shown below.

 ~~~~
+:::text
 command DoThis
     throws Exception
   ' Run some code that might throw Exception
@@ -28,6 +29,7 @@
 If a property needs to throw an exception, the **[throws](keywords-throws)** clause should be applied to the accessor, not the property.

 ~~~~
+:::text
 property String MyProp
   get
       throws Exception
@@ -42,6 +44,7 @@
 If you need to **[catch](keywords-catch)** rather than declare an exception, use this syntax:

 ~~~~
+:::text
 try
   ' code that might throw an exception
 catch Exception e
@@ -53,6 +56,7 @@
 This sample show how to handle multiple exception types:

 ~~~~
+:::text
 try
   ' code that might throw several different types of exceptions
 catch ExceptionA e
@@ -68,6 +72,7 @@
 You can use a **[finally](keywords-finally)** block to ensure a variable is initialized or to allow the garbage collector to deallocate a variable.

 ~~~~
+:::text
 try
   ' Code the might throw an exception
 catch Exception e
@@ -81,6 +86,7 @@
 If you're declaring exceptions rather than catching them, you still might want a **[try](keywords-try)** block so you can have a **[finally](keywords-finally)** block clean up.

 ~~~~
+:::text
 command CallMe
     throws Exception
   try

Exceptions modified by Will Pittenger

Will Pittenger — Thu, 13 Feb 2014 23:20:24 -0000

--- v2
+++ v3
@@ -8,14 +8,14 @@
 Exception base class/interface | What it does
 -------------------------------|-------------
 IThrowable | All exception classes must implement this interface
-Exception | If a property or procedure throws anything of type Exception or any class derived from Exception, it must be declared with the [**throws**] clause or handled with a [**try**]/[**catch**] block.
-Error | This is an [**abstract**] class whose derived types don't need to be caught.  They are meant for dynamic errors.
+Exception | If a property or procedure throws anything of type Exception or any class derived from Exception, it must be declared with the **[throws](keywords-throws)** clause or handled with a **[try](keywords-try)**/**[catch](keywords-catch)** block.
+Error | This is an **[abstract](keywords-abstract)** class whose derived types don't need to be caught.  They are meant for dynamic errors.

 Even though exceptions of type Error don't need to be caught, all compilers should provide an option to require instances of an Error type and its derivatives to be caught.  This could be useful when the author of a exception class use Error when they should have picked Exception as their base type.

-The [**throws**] clause
+The **[throws](keywords-throws)** clause
 -----------------
-The [**throws**] keyword can be applied to any procedure as shown below.
+The **[throws](keywords-throws)** keyword can be applied to any procedure as shown below.

 ~~~~
 command DoThis
@@ -23,9 +23,9 @@
   ' Run some code that might throw Exception
 ~~~~

-The [**throws**] clause in properties
+The **[throws](keywords-throws)** clause in properties
 -----------------------------------
-If a property needs to throw an exception, the [**throws**] clause should be applied to the accessor, not the property.
+If a property needs to throw an exception, the **[throws](keywords-throws)** clause should be applied to the accessor, not the property.

 ~~~~
 property String MyProp
@@ -37,9 +37,9 @@
   ' This accessor doesn't throw any exceptions
 ~~~~

-Simple [**try**]/[**catch**] blocks
+Simple **[try](keywords-try)**/**[catch](keywords-catch)** blocks
 -----------------------
-If you need to [**catch**] rather than declare an exception, use this syntax:
+If you need to **[catch](keywords-catch)** rather than declare an exception, use this syntax:

 ~~~~
 try
@@ -48,7 +48,7 @@
   ' handle the exception
 ~~~~

-Multiple [**catch**] blocks for one [**try**] block
+Multiple **[catch](keywords-catch)** blocks for one **[try](keywords-try)** block
 ---------------------------------------
 This sample show how to handle multiple exception types:

@@ -65,7 +65,7 @@

 Finally blocks
 --------------
-You can use a [**finally**] block to ensure a variable is initialized or to allow the garbage collector to deallocate a variable.
+You can use a **[finally](keywords-finally)** block to ensure a variable is initialized or to allow the garbage collector to deallocate a variable.

 ~~~~
 try
@@ -76,9 +76,9 @@
   ' clean up
 ~~~~

-Try blocks with a [**finally**] block but no [**catch**] blocks
+Try blocks with a **[finally](keywords-finally)** block but no **[catch](keywords-catch)** blocks
 ---------------------------------------------------
-If you're declaring exceptions rather than catching them, you still might want a [**try**] block so you can have a [**finally**] block clean up.
+If you're declaring exceptions rather than catching them, you still might want a **[try](keywords-try)** block so you can have a **[finally](keywords-finally)** block clean up.

 ~~~~
 command CallMe
@@ -91,4 +91,4 @@

 Possible syntax errors
 ----------------------
-If you have a [**try**] block, you must either follow it with at least one [**catch**] block or a [**finally**] block.  All compilers must catch this situation.
+If you have a **[try](keywords-try)** block, you must either follow it with at least one **[catch](keywords-catch)** block or a **[finally](keywords-finally)** block.  All compilers must catch this situation.

Exceptions modified by Will Pittenger

Will Pittenger — Sat, 08 Feb 2014 13:55:04 -0000

--- v1
+++ v2
@@ -7,15 +7,15 @@

 Exception base class/interface | What it does
 -------------------------------|-------------
-IThrowable | All exception classes must inherit this interface
-Exception | If a property or procedure throws anything of type Exception or any class derived from Exception, it must be declared with the **throws** clause or handled with a try/catch block.
-Error | This is an abstract class whose derived types don't need to be caught.  They are meant for  dynamic errors.
+IThrowable | All exception classes must implement this interface
+Exception | If a property or procedure throws anything of type Exception or any class derived from Exception, it must be declared with the [**throws**] clause or handled with a [**try**]/[**catch**] block.
+Error | This is an [**abstract**] class whose derived types don't need to be caught.  They are meant for dynamic errors.

 Even though exceptions of type Error don't need to be caught, all compilers should provide an option to require instances of an Error type and its derivatives to be caught.  This could be useful when the author of a exception class use Error when they should have picked Exception as their base type.

-The **throws** clause
+The [**throws**] clause
 -----------------
-The [throws] keyword can be applied to any procedure as shown below.
+The [**throws**] keyword can be applied to any procedure as shown below.

 ~~~~
 command DoThis
@@ -23,9 +23,9 @@
   ' Run some code that might throw Exception
 ~~~~

-The **throws** clause in properties
+The [**throws**] clause in properties
 -----------------------------------
-If a property needs to throw an exception, the **throws** clause should be applied to the accessor, not the property.
+If a property needs to throw an exception, the [**throws**] clause should be applied to the accessor, not the property.

 ~~~~
 property String MyProp
@@ -37,9 +37,9 @@
   ' This accessor doesn't throw any exceptions
 ~~~~

-Simple try/catch blocks
+Simple [**try**]/[**catch**] blocks
 -----------------------
-If you need to catch rather than declare an exception, use this syntax:
+If you need to [**catch**] rather than declare an exception, use this syntax:

 ~~~~
 try
@@ -48,7 +48,7 @@
   ' handle the exception
 ~~~~

-Multiple catch blocks for one try block
+Multiple [**catch**] blocks for one [**try**] block
 ---------------------------------------
 This sample show how to handle multiple exception types:

@@ -65,7 +65,7 @@

 Finally blocks
 --------------
-You can use a finally block to ensure a variable is initialized or to allow the garbage collector to deallocate a variable.
+You can use a [**finally**] block to ensure a variable is initialized or to allow the garbage collector to deallocate a variable.

 ~~~~
 try
@@ -76,9 +76,9 @@
   ' clean up
 ~~~~

-Try blocks with a finally block but no catch blocks
+Try blocks with a [**finally**] block but no [**catch**] blocks
 ---------------------------------------------------
-If you're declaring exceptions rather than catching them, you still might want a try block so you can have a finally block clean up.
+If you're declaring exceptions rather than catching them, you still might want a [**try**] block so you can have a [**finally**] block clean up.

 ~~~~
 command CallMe
@@ -91,4 +91,4 @@

 Possible syntax errors
 ----------------------
-If you have a try block, you must either follow it with at least one catch block or a finally block.  All compilers must catch this situation.
+If you have a [**try**] block, you must either follow it with at least one [**catch**] block or a [**finally**] block.  All compilers must catch this situation.

Exceptions modified by Will Pittenger

Will Pittenger — Wed, 05 Feb 2014 10:48:49 -0000

Overview
The throws clause
The throws clause in properties
Simple try/catch blocks
Multiple catch blocks for one try block
Finally blocks
Try blocks with a finally block but no catch blocks
Possible syntax errors

Overview

Exception handling in ASIL is largely modeled after Java's exception handling. Exceptions must derive from one of the following:

Exception base class/interface	What it does
IThrowable	All exception classes must inherit this interface
Exception	If a property or procedure throws anything of type Exception or any class derived from Exception, it must be declared with the throws clause or handled with a try/catch block.
Error	This is an abstract class whose derived types don't need to be caught. They are meant for dynamic errors.

Even though exceptions of type Error don't need to be caught, all compilers should provide an option to require instances of an Error type and its derivatives to be caught. This could be useful when the author of a exception class use Error when they should have picked Exception as their base type.

The throws clause

The [throws] keyword can be applied to any procedure as shown below.

command DoThis
    throws Exception
  ' Run some code that might throw Exception

The throws clause in properties

If a property needs to throw an exception, the throws clause should be applied to the accessor, not the property.

property String MyProp
  get
      throws Exception
    ' Run some code that might throw Exception

  set
  ' This accessor doesn't throw any exceptions

Simple try/catch blocks

If you need to catch rather than declare an exception, use this syntax:

try
  ' code that might throw an exception
catch Exception e
  ' handle the exception

Multiple catch blocks for one try block

This sample show how to handle multiple exception types:

try
  ' code that might throw several different types of exceptions
catch ExceptionA e
  ' Handle this exception
catch ExceptionB e
  ' Handle this one
catch Exception e
  ' Handle all other exceptions

Finally blocks

You can use a finally block to ensure a variable is initialized or to allow the garbage collector to deallocate a variable.

try
  ' Code the might throw an exception
catch Exception e
  ' Handle that exception
finally
  ' clean up

Try blocks with a finally block but no catch blocks

If you're declaring exceptions rather than catching them, you still might want a try block so you can have a finally block clean up.

command CallMe
    throws Exception
  try
    ' Do something that might throw an exception
  finally
    ' clean up, but don't handle the exception

Possible syntax errors

If you have a try block, you must either follow it with at least one catch block or a finally block. All compilers must catch this situation.