Thanks..
The Ada 95 standard does not define how to interface with C++.
Your compiler may define this on its own; you'll have to consult the
compiler docs.
--
-- Stephe
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;
There are detailed instructions in the Apex documentation on how to do
this,
and they do work.
The part that isn't mentioned, though, is that the C++ _must_ be
compiled
with Apex C++. Otherwise the run-time environments conflict, and the
resulting executable runs unreliably, if at all, which was our
experience.
This rather significant restriction was stated by a Rational
representative.
Originally, the C++ code we had to link in was compiled with Sun's Forte
C++, and we were fortunate that the nature of the code was highly
algorithmic and portable, so compiling it with Apex C++ went quite
smoothly.
Marc A. Criley
Quadrus Corporation
www.quadruscorp.com
"Marc A. Criley" <mc...@earthlink.net> wrote in message
news:3DA6B3DA...@earthlink.net...
John Smith
"Matthew Heaney" <mhe...@on2.com> wrote in message
news:uqbtbu...@corp.supernews.com...
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" <mhe...@on2.com> wrote in message
news:uqbtbu...@corp.supernews.com...
>
"Jeffrey Creem" <je...@thecreems.com> wrote in message
news:Z3Jq9.48415$oq6.12550@sccrnsc01...
Smart compiler. :-)