Internal Errors
Internal errors are due to faulty logic or coding in the program. Common types of internal errors include:
• Bounds errors
• Inserting a null pointer into a collection
• Attempting to use a bad date
All these errors should be preventable. For example, you always know the permissible range of indices for an array, so you can probably avoid a bounds error. You would correct your program's use of a bad date as an obvious logic error.
Internal errors can be further classified according to the cost of error detection, and whether or not the error will be detected at run time. The two categories are:
• Non-recoverable internal errors
• Recoverable internal errors
Non-recoverable Internal Errors
Non-recoverable internal errors share the following distinguishing characteristics. They are:
• Easily predicted in advance
• Encountered at relatively low levels
• Costly to detect
• Detected only in the debug version of the library
Non-recoverable internal errors by definition have no recovery mechanism. Examples of these errors include bounds errors and inserting a null pointer into a collection.
A library defines some errors unrecoverable because detecting errors takes time. For performance reasons, a library demands a minimal level of accuracy and rejects any part of your program that falls short. Errors are non-recoverable in the sense that the production version of the library has no mechanism for detecting such errors. This means there is no opportunity to recover from them.
Bounds errors are non-recoverable because the cost of checking that an index is in range can well exceed the cost of the array access itself. If a program does a lot of array accesses, checking every one may result in a slow program. To avoid this, the library may require you to always use a valid index. Because a minimum level of accuracy is demanded, non-recoverable errors are simple in concept and relatively easy to avoid.
You can best discover and eliminate non-recoverable errors by compiling and linking your application with the debug version of the library. See
“The Debug Version of the Essential Tools Module” in this chapter for details. The debug version includes extra checks designed to uncover coding errors. Some of these checks may take extra time, or even cause debug messages to be printed. For this reason, you will want to compile and link with the production version for an efficient final product. If the debug version of the library discovers an error, it typically aborts the program.
Recoverable Internal Errors
Recoverable internal errors are similar to their non-recoverable relatives because they are easy to predict and occur at low levels.
They differ in that they are
• not costly to detect
• detected in both the debug and the production versions of the library
A bounds error in a linked list or an attempt to use an invalid date are both examples of recoverable internal errors. The library's response to these errors is to throw an exception inheriting from
RWInternalErr, using the macro
RWTHROW.
The production version of the library can check for recoverable internal errors because the cost is relatively low. For example, to find a bounds error in a linked list, the cost of walking the list far exceeds the cost of detecting whether the index is in bounds. Hence, you can afford to check for a bounds error on every access.
If an error is discovered, the library throws an exception inheriting from
RWInternalErr, as we have mentioned. Following is an example:
// Find link "i"; the index must be in range:
RWIsvSlink* RWIsvSlist::at(size_t i) const
{
if (i >= entries()){
if(RW_NPOS == i)
RWTHROW( RWBoundsErr("NPOS index"));
else
RWTHROW( RWBoundsErr("Index out of bound"));
}
register RWIsvSlink* link = head_.next_;
while (i--) link = link->next_;
return link;
}
In this code, note how the function
always attempts to detect a bounds error. If it finds one, it throws an instance of
RWBoundsErr, a class that inherits from
RWInternalErr.
Throwing an exception gives you the opportunity to catch and possibly recover the exception. However, because the internal logic of the program has been compromised, you should attempt to save the document you are working on, and abort the program.