Re: Ada exception block does NOT work?

[Jean-Pierre Rosen <rosen@adalog.fr>]

Maciej Sobczak a �crit :
> Jeffrey R. Carter wrote:
> 
>> Ada has had exceptions, well integrated with the rest of the language, 
>> since Ada 80. Ada's terminology is that exceptions are raised and 
>> handled.
> 
> 
> OK, but the question is not about terminology, really.
> 
> If you claim that exceptions were "patched" on to the C++ language that 
> did not have them originally, then let's switch the context to other 
> language that has no history issue like this.
There are no predefined exceptions in C++, therefore things like 
arithmetic overflow have undefined semantics, rather than raising an 
exception

[...]
> 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. 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.

> Note that those other languages can throw regular objects as exceptions, 
> thus enabling polymorphism when they are handled. One could say that 
> *this* is the point of good integration and that Ada's exceptions are a 
> conceptual patch that did not integrate with the rest of the object 
> model, leading to two separate spaces of language entities instead of 
> only one.
This boils down to the (controversial) question of how much information 
should be associated to an exception. It could be the programmer's 
responsibility to store the context when an exception is raised, rather 
than propagating it with the exception. In Ada83, an exception had just 
an identity, and Jean Ichbiah (the father of Ada) claimed that he 
regretted having more than one exception. In Ada95, a string can be 
associated to an exception. In C++, any object can be thrown, while in 
Java only an object belonging to the throwable class. Note also that 
augmenting the quantity of information associated to an exception has a 
performance cost, which may be important for a real-time oriented 
language like Ada. So, you see the question is quite open...

-- 
---------------------------------------------------------
            J-P. Rosen (rosen@adalog.fr)
Visit Adalog's web site at http://www.adalog.fr