Re: Problem with access parameter

[Dmitry A. Kazakov <mailbox@dmitry-kazakov.de>]

On 25 May 2004 07:00:48 -0700, jimmaureenrogers@worldnet.att.net (Jim
Rogers) wrote:

>402450@cepsz.unizar.es (Jano) wrote in message news:<5d6fdb61.0405250252.3a1f1f68@posting.google.com>...

>> I'm trying to finalize data inside a protected type, using the
>> approach pasted at the end. I'm not sure if I get this bizarre error
>> because of a Gnat 3.15p bug or because what I'm trying is illegal:
>> 
>> agpl-counter-multi.ads:59:04: expected an access type with designated
>> type "Object" defined at line 59
>> agpl-counter-multi.ads:59:04: found an access type with designated
>> type derived from "Object" defined at line 59
>> agpl-counter-multi.ads:59:04:   ==> in call to "_Init_Proc" at line 73
>> 
>> The package code is: (trimmed)
>> 
>> package Agpl.Counter.Multi is
>> 
>>    type Object;
>>    type Object_Access is access all Object;
>> 
>>    type Destructor_Type (Parent : access Object) is limited private; 
>
>The discriminant type is not the same as Object_Access. It is an
>anonymous type. If you want to use Object_Access as the discriminant type
>then specify this clearly.

It is pretty legal for record types. For example:

   type Object;
   type Destructor_Type (Parent : access Object) is limited private; 
   type Object is limited record
      Destructor : Destructor_Type (Object'Access);
   end record;
private
   type Destructor_Type (Parent : access Object) is
      new Ada.Finalization.Limited_Controlled with null record;
   procedure Finalize (This : in out Destructor_Type);

I am not sure, but it seems to be allowed for record types only
3.8(12).

>>    ----------------------------------------------------------------
>>    -- Object                                                     --
>>    ----------------------------------------------------------------
>>    protected type Object is
>>       -- Things
>>    private
>>       procedure Destroy;
>>       Destructor : Destructor_Type (Object'Access);
>
>Object is the name of a type. You cannot take the access value of a type,
>only of an instance.

See above.

>It looks like you are trying to create something equivalent to a C++ or Java
>"this" reference. What are you trying to achieve?

It looks that he wants a destructor for a protected object. A rightful
wish, or? Because protected types are not and cannot be derived from
Limited_Controlled, he tries to inject a controlled member pointing to
the protected parent. When parent gets finalized, the member's
Finalize is called with access to parent's as the discriminant.

>>       Values     : Counter_Map.Container_Type;
>>    end Object;
>> 
>> private
>> 
>>    type Destructor_Type (Parent : access Object) is new   
>>    Finalization.Limited_Controlled with null record;
>> 
>>    procedure Finalize (This : in out Destructor_Type);
>>    -- Here call to This.Parent.Destroy;
>
>You are trying to destroy a protected object from within itself.
>Such an operation can cause a large number of problems. What happens to
>tasks waiting in an entry queue for the protected object? Are they
>released from the queue? I do not believe the Ada Reference Manual
>specifies the results of such an operation.

That's no problem, because Finalize will be called upon parent's
finalization. At that point the parent is out of scope of anybody who
might use it. (if no dangling pointers used)

-----------------------------
Well, it seems that the trick won't work. So one should pack the
protected object into a limited controlled type and make proxies to
its entries and subprograms.

--
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de