Re: another way to shoot yourself in the foot?

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Ludovic Brenta <ludovic@ludovic-brenta.org> writes:

> Robert A Duff writes:
>> But in Ada 95, if you say:
>> 
>>     P(F(...));
>> 
>> where F returns limited, you are not passing a limited object,
>> but an implicit reference to some object that already existed before the
>> call to F.
> [...]
>> In Ada 2005, functions always return newly-created objects, which I
>> think is appropriate.
>
> This makes me wonder whether there is an actual difference in the way
> the compiler handles such returns.

Yes, very different in the case of limited types.

In Ada 83, F returns its result by copy, and the address of this copy is
passed to P.

In Ada 95, F returns the address of some object outside F,
and this address is passed to P.

In Ada 2005, the formal of P is allocated at the call site,
and the address of that is passed to F, which puts its result
there.  This address is then passed to P.  Except if the size
is not known at the call site, things get more complicated.
And if controlled types or task types are involved, then extra
implicit parameters are passed to F (who is the master of this
thing, who is supposed to activate it, etc).

>...For example, has GNAT changed a
> lot in this area?

Yes.  We're talking about months of work by at least two people at
AdaCore (one of whom was me).

>...Do the Ada 95 and Ada 2005 compatibility modes use
> antirely different compilation strategies?

Yes.  And if you try to mix them, it won't work.

>>     if F(...).Flag then ...
>>
>> The last one is pretty silly -- it creates a new limited object,
>> grabs a boolean flag out of it, and then throws the whole thing
>> away.
>
> Yes but "grabbing a boolean flag" might consist in passing the limited
> object as a parameter to a primitive function named Flag, which might
> then pass it down to any number of subprograms with all sorts of side
> effects.  One could write an arbitrarily large program like this :)

Good point.  I was talking about the case where the result is a limited
record with a component called Flag, which is silly.  You are talking
about the case where Flag is a primitive operation, which is not silly.

- Bob