Re: Refactoring and Ada

[dewar@gnat.com (Robert Dewar)]

Richard Riehle <richard@adaworks.com> wrote in message news:<3C7324BF.996E182B@adaworks.com>...
> Larry Kilgallen wrote:
> 
> > > What happens when you read junk off the interface?
> >
> > Doesn't 'Valid detect that ?
> 
> It turns out that 'Valid is not as useful as many of us 
> thought it was. Fo example,  the result of an erroneous 
> result from unchecked conversion

What do you mean  by "an erroneous result" from unchecked conversion.
The word erroneous does not appear in RM section 13.9.

Now it is true that UC is implementation defined, and one
can imagine an unusable implementation that "defines" the
action of some UC's to be the equivalent of erroneous, but
if you find such a compiler I suggest you file it in the
circular file, since it is working hard to be useless.

> which we originally 
> thought was harmless if we checked it ourselves
> with 'Valid before using it is a problem.   Consider the 
> following,
> 
>                type X is ... ;
>                type Y is ... ;
> 
>                function Convert is new 
>                  Ada.Unchecked_Conversion
>                    (Source => Y, Target => X);
> 
> 
>                 X := Convert (Y);     -- suppose X is 
>                        erroneous or not valid

First of all, a value can never be erroneous, this is sloppy
terminology. Only a program execution can be
erroneous, and certainly one does NOT expect the above to
be erroneous on any reasonable compiler. A compiler would
have to explicitly document this as erroneous, and it would
be treading on thin ice, since the idea of implementation defined is
to exclude erroneous behavior. Yes a language
lawyer can argue that erroneousity is included in the range of
possible impl defined values, but that's no excuse for
a compiler to malfunction this way. There are many many
ways in which compilers can be made unusable, this is one
of them, and there is no reason to put up with it.


>                 if X'Valid then ...      -- We used to 
>                   think this was OK.

It's just fine

>                                                  -- Some 
> compilers fail on this because of an
> interpretation of the ALRM rules.

There is no interpretation involved here, this is a matter
of implementation defined behavior.

>  At present, one must wonder about the usefulness of 
> 'Valid.


That's like finding a compiler that does all multiplications by
repeated addition and then wondering about the utility of the *
operator in Ada.

On a decent compiler, the above works fine, and is a useful
(and commonly used) use of 'Valid.