Help with Gnat Cross-compile

Help with Gnat Cross-compile

[Samuel G. Williams]

I am looking for good examples on two scenarios. The first is the compile of 
Ada code for later linking in C. I would also like any recommendations for call
converntions. Second I am looking for the reverse. Being able to compile c 
then link in with Ada also with the calling conventions. I am currently 
attempting to help a friend without an Internet connection obtain this 
information. I would welcome all replies. BTW he is using GNAT on a Solaris 
workstation. He found brief entries in the GNAT UG but didn't quite 
understand them well enough to be useful. 

Thanks in advance for your help.

--

Sam Williams  wb5yni					samw@wwa.com
Systems Programmer Staff Specialist			samw@sinnfree.org
---------------------------------------------------------------------------

	simplicity is the ultimate form of sophistication....
			Leonardo Da Vinci

Re: Help with Gnat Cross-compile

[Ara Kassabian]

Samuel G. Williams wrote:
> 
> I am looking for good examples on two scenarios. The first is the compile of
> Ada code for later linking in C. I would also like any recommendations for call
> converntions. Second I am looking for the reverse. Being able to compile c
> then link in with Ada also with the calling conventions. I am currently
> attempting to help a friend without an Internet connection obtain this
> information. I would welcome all replies. BTW he is using GNAT on a Solaris
> workstation. He found brief entries in the GNAT UG but didn't quite
> understand them well enough to be useful.
> 
> Thanks in advance for your help.
> 

In Ada-83, interfacing with C was as easy as using the right pragmas, so long as
you didn't run into threading issues (both the C and Ada-83 parts of our program
were threaded, and the two threading packages were not aware of each other). It
*should* be just as easy with GNAT. The procedure should be:

1. Calling C from Ada: Write a package spec declaring the C functions and using
"pragma import", so Ada knows it needs to use C calling conventions.

2. Calling Ada95 from C: Write a header file with the Ada95 function/procedure
prototypes. If you cannot turn off name mangling in Ada95 using a pragma, then
you need to compile your files, figure out the mangled names by looking in the
object files and use those as your function names in your C header files. You
make things look pretty by using #define to create unmangled aliases for the
mangled functions. You *may* run into problems with Ada95 procedures. I am not
sure if they equate to void functions in C.

------------------------------------------------------
Ara Kassabian            akass@worldnet.att.net
                         akassabian@logicon.com (work)
------------------------------------------------------

Re: Help with Gnat Cross-compile

[Robert Dewar]

Ara said

<<In Ada-83, interfacing with C was as easy as using the right pragmas, so long as
you didn't run into threading issues (both the C and Ada-83 parts of our program
were threaded, and the two threading packages were not aware of each other). It
*should* be just as easy with GNAT. The procedure should be:

1. Calling C from Ada: Write a package spec declaring the C functions and using
"pragma import", so Ada knows it needs to use C calling conventions.

2. Calling Ada95 from C: Write a header file with the Ada95 function/procedure
prototypes. If you cannot turn off name mangling in Ada95 using a pragma, then
you need to compile your files, figure out the mangled names by looking in the
object files and use those as your function names in your C header files. You
make things look pretty by using #define to create unmangled aliases for the
mangled functions. You *may* run into problems with Ada95 procedures. I am not
sure if they equate to void functions in C.
>>


This is completely incorrect advice if you are using Ada 95. Things are
FAR simpler and FAR more portable in Ada 95, and indeed most of what you
need and want is right there in annex B in the RM. There is no need to
investigate mysterious system dependent "mangling" what ever that might be!

Indeed the advice as given in section 2 above is not even correct for Ada 83,
since it ignores elaboration issues, which often proved extremely difficult
to solve in Ada 83. Again in Ada 95, you can look in the RM to find out how
to handle the elaboration problem.