Re: Passing the same actual as both in and out formal parameters?

["Jeffrey R. Carter" <spam.jrcarter.not@spam.acm.org>]

Adam Beneschan wrote:
> On Nov 17, 4:11 pm, "Jeffrey R. Carter"
> <spam.jrcarter....@spam.acm.org> wrote:
>>
>> pragma Assert (A'access /= B'access);
> 
> First of all, for this to work in the general case, that would need a
> major change in language semantics, since you need an access type in
> order for 'Access to be allowed.  The only way this would be legal is
> if there happened to be exactly one "=" operator directly visible with
> operands of some named access-to-T type.  (Also, if "=" were
> overridden with a user-defined operator that did something unexpected,
> it would fail, but nobody would do that.)

OK. Since this in the body of the operation, it seems doable:

procedure P (A : in T; B : out T) is
    type T_Ptr is access T;

    A_Ptr : constant T_Ptr := A'access;
    B_Ptr : constant T_Ptr := B'access;

    pragma Assert (A_Ptr /= B_Ptr);

So you're guaranteed that "=" for T_Ptr is used, and you know it hasn't been 
overridden.

What about 'Address?

> Second, it only catches the case where the operands are of the same
> type; it won't catch other overlaps such as
> 
>    P2 (A => Object, B => Object.Component);

Sure, it's not a general solution; I doubt if there could be one. But it does 
seem to serve for the OP's case.

-- 
Jeff Carter
"You cheesy lot of second-hand electric donkey-bottom biters."
Monty Python & the Holy Grail
14