TRY_CATCH()

TRY_CATCH()

[Andrew Cagney]

Hello,

The exceptions rewrite opens up a key possibility.  It's now possible to 
define a macro such that:

   struct args
   {
     ...
   };

   do_func (void *data)
   {
     struct args *args = data;
     ... do stuff ...;
   }

   func (...)
   {
     struct args args;
     args... = ...;
     struct exception e = catch_exception (..., func, &args, ...)
     switch (e.reason)
       ...
   }

can be replaced with the more compact:

   func (...)
   {
     volatile struct exception e;
     TRY_CATCH (e)
       {
         ... do stuff ...;
       }
     switch (e.reason)
       ...
   }

Yes I know macros a bad, m'kay.  However, this offers a simple way to 
rewrite the code using something more like a real programming languages 
try/catch.

Andrew

PS: I recall this being proposed years ago, but the mechanism proposed 
at the time had a more cumbersom syntax, from memory something like:

   TRY_BEGIN
     ... do stuff ...
   TRY_END;

comments?
Andrew

Re: TRY_CATCH()

[Kris Warkentin]

Andrew Cagney wrote:

>PS: I recall this being proposed years ago, but the mechanism proposed 
>at the time had a more cumbersom syntax, from memory something like:
>
>   TRY_BEGIN
>     ... do stuff ...
>   TRY_END;
>  
>

I saw something similar to this that worked really well but was not 
quite as generic.  Basically you would have to add a 'TryStack' member 
to whatever data structure you were planning to capture exceptions on.  
The TryStack was a stack of jmp_bufs.  Then you'd do something like

if((error = TRY(mystruct)) == 0){
    do_stuff(mystruct);
    TRY_END(mystruct->try_stack);
}
else{
    CATCH(mystruct, error);
    handle_error();
}

The TRY would push a new jmp_buf onto the TryStack and the TRY_END and 
CATCH would pop one.  The various macros would be like #define TRY(foo) 
is try_push(foo->try_stack) and so on.  It's actually quite clever:  If 
something THROWs, it also pops but CATCH only pops if the error value is 
zero so that you can have multiple tries and catches on a single block.

Anyway, interesting stuff.

cheers,

Kris

Re: TRY_CATCH()

[Frank Ch. Eigler]

cagney wrote:

> [...]
>    func (...)
>    {
>      volatile struct exception e;
>      TRY_CATCH (e)
>        {
>          ... do stuff ...;
>        }
>      switch (e.reason)
>        ...
>    }
> [...]
> comments?

At this rate, by around 2009, gdb will have reimplemented 
the remainder of C++.

- FChE