Problem - Kevin Tafuro

tion gets caught. The only ways to avoid running such a block are to do one of
the following:
• Return from the current function.
• Use goto to jump to a label outside the exception-handling block.
• Break the abstraction that the XXL macros provide.
All of these techniques are bad form. Circumventing the XXLexception structure
will cause its exception handler stack to enter an inconsistent state, resulting
in unexpected and often catastrophic behavior. You should never return
from within a TRY, CATCH, EXCEPT, orFINALLY block, nor should you ever use any
other method, such as goto or longjmp, to jump between blocks or outside of
them.
• XXLrequires you to use END_TRY. This is necessary because of the way XXLis
implemented as preprocess macros; true exception handling requires handling at
the language level, which is a luxury that we do not have with C.
• The syntax for actually raising an exception differs. XXLhas a THROW() macro
that takes two parameters. The first is the exception code, and the second is a
void *, representing arbitrary data that you might want to pass from the site of
the raise to the exception handler. It is acceptable to pass in a NULL value as the
second parameter if you have no need for it.
If you want to get the extra information (the void *) passed to the THROW( )
macro from within an exception handler (specifically, a CATCH(), EXCEPT, or
FINALLY block), you can do so by calling EXCEPTION_INFO( ).
• In some cases, the XXLmacro set may conflict with symbols in your code. If that
is the case, each also works if you prepend XXL_ to the macro. In addition, you
can turn off the basic macros by defining XXL_ENFORCE_PREFIX when compiling.
Once you have an exception-handling mechanism in place, we recommend that you
avoid calling functions that can return an error when they fail.
For example, consider the malloc( ) function, which can return NULL and set errno to
ENOMEM when it fails (which only happens when not enough memory is available to
complete the request). If you think you will simply want to bail whenever the process
is out of memory, you could use the following wrapper:
#include
void *my_malloc(size_t sz) {
void *res = malloc(sz);
if (!res) {
/* We could, instead, call an out of memory handler. */
fprintf(stderr, "Critical: out of memory! Aborting.\n");
abort( );
}
return res;
}
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Performing Error Handling | 703