Re: Ada exception block does NOT work?

[Maciej Sobczak <no.spam@no.spam.com>]

Jean-Pierre Rosen wrote:

> There are no predefined exceptions in C++

There are.
In particular, creating a new object on the free store can result in 
failure due to inability of the system to allocate memory. This is how 
you create new object on the free store:

int *p1 = new int;
MyType *p2 = new MyType();

etc.

In case of memory allocation error, the above will result in the 
std::bad_alloc exception being thrown.
This is predefined and standard exception in C++.

> therefore things like 
> arithmetic overflow have undefined semantics

The "therefore" part above is not correct. Since there *are* predefined 
exceptions in C++, dealing with arithmetic anomalies certainly was based 
on other, unrelated policies.
Whether this is good or bad in any particular context is another issue.


>> Why do you claim that Ada's exceptions are "better integrated into the 
>> language than in the languages that throw and catch them"?
> 
> Every sequence of statements can have an exception handler in Ada, while 
> in C++/Java/C# you must add an extra level of nesting.

You add the nesting if you want to handle the exception. If you don't 
want to handle it, you don't add the nesting. This is rather the result 
of having a *pair* of parentheses to denote a block, with no sensible 
way of extending this punctuation. In Ada, "begin" and "end" are not a 
closed pair and are easier to extend with any other keyword, thus making 
a "comb" of arbitrary length. But this is a syntax issue.

I treat Ada's "begin" as having implicit "try" if there is any handler 
downstream. Is there anything inherently wrong in this?

> This gives the 
> feeling that dealing with exceptions is something you just put in very 
> special places, while in Ada you are more inclined to considering 
> exceptions everywhere.

But then we will drift to discuss whether it makes sense to deal with 
exceptions everywhere or maybe only where the actual handler has 
something to do. I haven't seen enough real Ada code to have any opinion 
what is good in the Ada context.
Don't you do this:

begin
     -- ...
     Some_Procedure_That_Might_Raise;
     -- ...
end;

and just let the exception (if any) travel up the chain to where there 
is enough context to actually *do* somethng with the exception?


>> Note that those other languages can throw regular objects as 
>> exceptions
> 
> This boils down to the (controversial) question of how much information 
> should be associated to an exception.
[...]
> So, you see the question is quite open...

Yes, it is and I understand the concerns you mention. But I'm still not 
sure about the "integration with the language" issue. In what way the 
Ada exceptions are more integrated with the language than the C++ 
exceptions (or take any other language from the "throwing" family)?


-- 
Maciej Sobczak : http://www.msobczak.com/
Programming    : http://www.msobczak.com/prog/