Re: Dispatching callback handed over to C

["Randy Brukardt" <randy@rrsoftware.com>]

Your code looks OK to me. (But I didn't try to compiler or use it, so there 
may be something I missed.)

                               Randy.

"Natasha Kerensikova" <lithiumcat@gmail.com> wrote in message 
news:slrnjnqoga.1lme.lithiumcat@sigil.instinctive.eu...
> On 2012-04-04, Randy Brukardt <randy@rrsoftware.com> wrote:
>> For instance, that's how we find the Ada object in Claw; we
>> unchecked-convert access-to-class-wide to a DWord in Windows, and then 
>> when
>> we need to use it, we unchecked-convert back. If I needed to make this
>> totally portable and had sufficient control over the API, I'd replace the
>> DWord by a locally-declared modular type of which I could control the 
>> size
>> to match the target. But there is little point in going further than 
>> that.
>>
>> System.Address is the wrong type to use for a "bucket-of-bits". I agree 
>> that
>> it would be nice to be able to directly put the access-to-class-wide in 
>> the
>> C convention record (and most compilers will in fact allow this, after
>> giving some warnings), but it doesn't seem to make that much difference.
>
> So for my binding, what about something like :
>
>   type Opaque_Data is null record;
>   pragma Convention (C, Opaque_Data);
>
>   type Opaque_Pointer is access all Opaque_Data;
>   pragma Convention (C, Opaque_Pointer);
>
>   type Callback_Access is access all Event_Callback'Class;
>   pragma Convention (C, Callback_Access);
>
>   procedure Set_C_Callback (<various arguments>;
>                             Data : Opaque_Pointer);
>   pragma Import (C, Set_C_Callback, "set_callback");
>
>
>   procedure Called_From_C (<various arguments>;
>                            Data : Opaque_Pointer)
>   is
>      package To_Ada is new Ada.Unchecked_Conversion
>        (Source => Opaque_Pointer, Target => Callback_Access);
>
>      Callback : Callback_Access := To_Ada (Data);
>   begin
>      Callback.all.Handle (<...>);
>   end Called_From_C;
>
>   pragma Convention (C, Called_From_C);
>
>
>   procedure Set_Callback (<various arguments>;
>                           Callback : in out Event_Callback'Class)
>   is
>      package To_C is new Ada.Unchecked_Conversion
>        (Source => Callback_Access, Target => Opaque_Pointer);
>   begin
>      Set_C_Callback (<...>, To_C (Callback'Access));
>   end Set_Callback;
>
> As far as I cen tell, Opaque_Pointer refers only to types compatibles
> with C, so the imports goes well and without warning, while
> Opaque_Pointer and Callback_Access, being both access types with the
> same convention, ensures they can be safely (in terms of keeping the
> bit pattern intact, of course not type-safety) converted back and forth.
>
> Or is there some trap in the above code that I'm missing?
>
>
> Thanks for your help,
> Natasha