Quickly exiting from nested calls

[Spiros Bousbouras]

Assume you have a library which contains the functions
foo1, ... , foon which the outside world knows about and
may call and the functions bar1, ... , barm which the outside
world doesn't know about. The library code does not call
anywhere the foo functions but any of the foo or bar functions
may call any bar function.

So let's say that a bar function (or it could be one of the foo
functions) detects an error serious enough that whatever foo
function was originally called cannot perform its task so the
only thing that can be done is to return with as little fuss as
possible to the outside world and report somehow the error.

How do you do that ?

The best solution I could think of goes as follows:
For every foo function you have a corresponding realfoo
function which takes the same list of arguments and has
the same return type as foo. The library code also contains
a global variable of type jmp_buf , let's call it env , and a
global variable mylib_errno of a type which is appropriate
for error reporting , int would probably do. The outside world
may or may not know about mylib_errno depending on whether
you want to report errors through the return values of the foo
functions or through mylib_errno.

So for some i with 1<= i <= n, fooi corresponding to realfooi would
look like this:

/* Same return type as realfooi */ fooi( /* List of arguments */ ) {
if ( setjmp(env) == 0 ) {
return realfooi( /* Same list of arguments fooi
was called with */ ) ;
/* If realfooi returns void then the return in the statement above
would be omitted.
*/
} else {
/* The bar function which detected the error will have put inside
mylib_errno an appropriate value and then called longjmp(env,1)

If errors get reported to the outside world through mylib_errno
then here we return with some random value if fooi has return
type other than void or we don't do anything if fooi returns void.
If errors do not get reported to the outside world through
mylib_errno then we return with some value appropriate for the
error.
*/
}
}

Comments ? Other ideas ?

[Eric Sosman]

Spiros Bousbouras wrote:

Assume you have a library which contains the functions
foo1, ... , foon which the outside world knows about and
may call and the functions bar1, ... , barm which the outside
world doesn't know about. The library code does not call
anywhere the foo functions but any of the foo or bar functions
may call any bar function.

So let's say that a bar function (or it could be one of the foo
functions) detects an error serious enough that whatever foo
function was originally called cannot perform its task so the
only thing that can be done is to return with as little fuss as
possible to the outside world and report somehow the error.

How do you do that ?

The best solution I could think of goes as follows:
For every foo function you have a corresponding realfoo
function which takes the same list of arguments and has
the same return type as foo. The library code also contains
a global variable of type jmp_buf , let's call it env , and a
global variable mylib_errno of a type which is appropriate
for error reporting , int would probably do. The outside world
may or may not know about mylib_errno depending on whether
you want to report errors through the return values of the foo
functions or through mylib_errno.

So for some i with 1<= i <= n, fooi corresponding to realfooi would
look like this:

/* Same return type as realfooi */ fooi( /* List of arguments */ ) {
if ( setjmp(env) == 0 ) {
return realfooi( /* Same list of arguments fooi
was called with */ ) ;
/* If realfooi returns void then the return in the statement above
would be omitted.
*/
} else {
/* The bar function which detected the error will have put inside
mylib_errno an appropriate value and then called longjmp(env,1)

If errors get reported to the outside world through mylib_errno
then here we return with some random value if fooi has return
type other than void or we don't do anything if fooi returns void.
If errors do not get reported to the outside world through
mylib_errno then we return with some value appropriate for the
error.
*/
}
}

Comments ? Other ideas ?

1) The globals env and mylib_errno make me uncomfortable.

2) Bailing out with longjmp() requires a strict discipline
in implementing the realfoo() and bar() function families. They
must be written in such a way that they never need to perform
any kind of cleanup -- like calling fclose() or free() -- after
calling a more deeply-nested realfoo() or bar(). I have never
seen a compiler or tool that's able to enforce such a discipline,
so you'll need to rely on nothing but vigilance.

3) If the bar() function knows enough about the foo() that
called it to make a unilateral decision that the foo() is doomed,
it seems to me there's something wrong with the architecture of
the library.

--
Eric Sosman
es*****@ieee-dot-org.invalid

[Mark McIntyre]

On Sat, 29 Sep 2007 07:45:06 -0700, in comp.lang.c , Spiros Bousbouras
<sp****@gmail.comwrote:

<snip description of library which needs to gracefully handle internal
errors>

>How do you do that ?

Modify the interfaces so that an error status can be returned by each
function and the result can be cascaded back up the call chain.

If you can't mod the interface, then provided you don't care about
re-entrancy, how about a global status variable?

--
Mark McIntyre

"Debugging is twice as hard as writing the code in the first place.
Therefore, if you write the code as cleverly as possible, you are,
by definition, not smart enough to debug it."
--Brian Kernighan

[Old Wolf]

On Sep 30, 3:45 am, Spiros Bousbouras <[e-mail]:

So let's say that a bar function (or it could be one of the foo
functions) detects an error serious enough that whatever foo
function was originally called cannot perform its task so the
only thing that can be done is to return with as little fuss as
possible to the outside world and report somehow the error.

How do you do that ?

The best solution I could think of goes as follows:
For every foo function you have a corresponding realfoo
function which takes the same list of arguments and has
the same return type as foo. The library code also contains
a global variable of type jmp_buf ,

Yikes! In my code I simply return a value from foo() that
indicates there was an error in bar(). For debugging
purposes I have all functions write a descriptive
message to a log file when they encounter an error.

[Spiros Bousbouras]

On Oct 11, 6:40 pm, Eric Sosman <[e-mail]:

Spiros Bousbouras wrote On 10/11/07 12:47,:

As for your example of bar1(), bar2(), and foo(),
I find it unconvincing. If I've understood your outline
correctly, foo() calls bar1() to open the stream, read
the entire thing into memory, and close the stream;

Not the entire thing ; bar1() reads bytes as needed. For
example a higher level function will decide it needs n
additional bytes from the stream to make a decision in its
parsing so it will tell bar1() "put n extra bytes into the
buffer". Also old bytes which do not influence the parsing
anymore get discarded so the buffer bar1 allocates may be
much smaller than the possible size of streams read.

I'm afraid I'm still missing something. Who closes the
input stream in the event of an error? foo? No, because
if bar1 or bar2 calls longjmp, foo will never get the chance.
bar1? No, because if foo or bar2 calls longjmp, bar1 will
never get the chance. bar2? No, same pattern. That's
why I assumed foo1 would do all the I/O in one gulp, so
it could close the stream before punting.

In the specific example I provided which you're not quoting
only bar1() may encounter a fatal error. In other situations
it may be that my method for error handling is not convenient;
as I've said I'm not claiming it's for every case.

There's an alternative: You could triplicate the cleanup
code in all three functions, so any of them could clean up
for itself and for the other two before punting. But that
would be really bad design, with no "it seems to me."

Or you could close the stream in the code which you call with
longjmp depending on the kind of error that occured.