Re: Rational Apex Ada - Pragma interface with C++

["John Smith" <someone@microsoft.com>]

Hello Matthew,

I just tried your suggestion, but I don't quite know how to link it.  I
compiled the C++ module that contains the externs with the CC compiler from
Sun OS and compiled the C code that interfaces with the C++ module with cc.
Now my problem is how do I link both together?  I've generated two object
files, but then I'm stuck.  Help please.

John


"Matthew Heaney" <mheaney@on2.com> wrote in message
news:uqbtbu6rtkk7b@corp.supernews.com...
>
> "John Smith" <someone@microsoft.com> wrote in message
> news:H3s05H.LMt@news.boeing.com...
> > Does anyone know how to use pragma interface for interfacing C++
functions
> > to an Ada program.  I know how to do it with C, but can't seem to get it
> to
> > work with C++.
>
> Interfacing with C++ requires care, especially if you have static
variables
> the require elaboration-time initialization.
>
> When a C++ program loads, all the statics get initialized.  There will be
> some code inserted by the compiler to go this, just prior to call the C++
> main.
>
> The same is true of an Ada program.
>
> In general, a C++ program will need a C++ main, and an Ada program will
need
> an Ada main.
>
> If you don't have any statics, you may OK.
>
> There's no official function you can call from an Ada program to perform
the
> C++ initialization -- you'll have to check your compiler docs.
>
> There are official functions to perform Ada initialization -- there are
two
> linker symbols called "adainit" and "adafinal".  If you have a C++ main,
and
> you're calling code written in Ada, then you'll need to call these.
>
> In any event, there's no pragma to interface with C++ directly.  I know
GNAT
> has compiler-specific pragmas to do this.
>
> However, I wouldn't bother.  Just create a C wrapper, and link to those.
> For example, if you have a C++ class you want to use from Ada, like this:
>
> class C
> {
> public:
>    void f();
> //...
> };
>
> Assuming you don't mind manipulating a pointer, you can do this:
>
> extern "C" C* makeC()
> {
>    return new C;
> }
>
> extern "C" void freeC(C* p)
> {
>    delete p;
> }
>
> extern "C" void c_f(C* p)
> {
>    p->f();
> }
>
> On the Ada side, create a set of bindings for each of the external
functions
> above, e.g.
>
> function Make_C return System.Address;
> pragma Interface (C, Make_C);
>
> procedure Free_C (Object : System.Address);
> pragma Interface (C, Free_C);
>
> procedure C_F (Object : System.Address);
> pragma Interface (C, C_F);
>
> You could add more type safety than I've shown above, e.g.
>
> package C_Types is
>
>    type C_Type (<>) is limited private;
>
>    type C_Access is access all C_Type;
>    pragma Convention (C, C_Access);
>
>    function New_C return C_Access;
>
>    procedure Free (C : in out C_Access);
>
>    procedure Do_F (C : access C_Type);
>
> private
>
>    type C_Type is null record;
>
>    function Make_C return C_Access;
>    pragma Interface (C, Make_C);
>
>   --etc
> end C_Types;
>
>
>
>