Ada Support FAQ

The following example illustrates how Ada can be interfaced to C++ static class members

Class MyClass {
static int TheAnswer;
public:
static int Question(); {
return TheAnswer;
}
MyClass
TheAnswer = 42;
}
};

int MyClass::TheAnswer;
MyClass mc;
void dummy() {
mc.Question();
}

Note: The function dummy() is present only to avoid the removal of the otherwise unreferenced member function.

-- Ada source
with Ada.Text_IO;
procedure Test is
function Question return integer;
pragma Import (Cdecl,
Question,
Link_Name => "?Question@MyClass@@SAHXZ"); -- decorated name
begin
Ada.Text_IO.Put_Line("The answer is" & integer'image(Question);
end Test;
-- end Ada source

Note: The "decorated name" supplied as argument to Link_Name may be extracted from an assembler listing of the C++ code or from a link map if it is linked into a program in its own right. For static members, use the convention Cdecl.

The following example illustrates how Ada may be interfaced to C++ virtual class members.

Class MyClass {
int TheAnswer;
public:
int Question(); {
return TheAnswer;
}
MyClass (int Clue) {
TheAnswer = Clue;
}
};

MyClass mc42(42);
MyClass mc69(69);
void cmain(){
mc42.Question();
mc69.Question();
}

-- Ada source code
with Ada.Text_IO;
with System;
procedure Test is
function Question (Class: in System.Address) return integer;
pragma Import (ThisCall,
Question,
Link_Name => "?Question@MyClass@@QAEHXZ"); -- decorated name

type Class_Record is
record
null; -- a dummy declaration
end record;

mc42, mc69: Class_Record;
pragma Import (C, mc42, link_name => "? mc42@@3VMyClass@@A");
pragma Import (C, mc69, link_name => "? mc69@@3VMyClass@@A");

begin
Ada.Text_IO.Put_Line("The answer is" &
integer'image(Question(mc42'address)));
Ada.Text_IO.Put_Line("The answer is" &
integer'image(Question(mc69'address)));
end Test;
-- end Ada source code

The Ada code must pass the address of the class object (mc42 or mc69 in the example above) as the first parameter to the member function and use the convention ThisCall. In this example, the class objects have external linkage and so can be referenced using link names. In other cases (automatic objects for example), the addresses must be conveyed to the Ada code by way of some user-defined mechanism.

• BuildCommDCB
• BuildCommDCBAndTimeouts
• ClearCommBreak
• ClearCommError
• CommConfigDialog
• DeviceIoControl
• EscapeCommFunction
• GetCommConfig
• GetCommMask
• GetCommModemStatus
• GetCommProperties
• GetCommState
• GetCommTimeouts
• GetDefaultCommConfig
• PurgeComm
• SetCommBreak
• SetCommConfig
• SetCommMask
• SetCommState
• SetCommTimeouts
• SetDefaultCommConfig
• SetupComm
• TransmitCommChar
• WaitCommEvent

• Package specifications
• Bodies of any generic packages that are available to be instantiated.
• Bodies of packages to which Pragma Inline is applied.

Many sample programs are included with the OAW CD-ROM. These samples may be found under %ObjectAda%\samples, where %ObjectAda% is the location of your ObjectAda installation. The %ObjectAda%\samples folder contains the following folders:

Yes. There are 31 priorities available to the Ada programmer. Under ETS ("ObjectAda Real-Time"), priorities 1..31 map directly to the ETS thread priorities -15..+15, but under Windows NT the only available priorities are:

Thread_Priority_Idle (-15)

Thread_Priority_Lowest (-2)

Thread_Priority_Below_Normal (-1)

Thread_Priority_Normal (0)

Thread_Priority_Above_Normal (+1)

Thread_Priority_Highest (+2)

Thread_Priority_Time_Critical (+15)

For a complete explanation of these priorities, see the Microsoft documentation. The following table describes the default mapping of Ada priorities to Windows NT priorities:

Because the mapping is many-to-one, it is possible that two tasks running at different Ada priorities may be mapped onto Windows NT threads executing at the same priority. If this is the case, the expected Ada semantics will not be observed; that is, the task of lower Ada priority may run in preference to that of higher priority. In this situation, you may choose to change the source code or to alter the priority mapping, which is represented as an array in the runtime and may be accessed in the following way:

type Priority_Map is array (System.Any_Priority) of Integer;

NT_Priority_Map : Priority_Map; -- initialized as above

pragma Import (C, NT_Priority_Map, "rts_nt_priority_map");

If the mapping array is altered dynamically, you must be careful to ensure that the array elements hold legal Windows NT priorities. The array must represent an appropriate mapping (there are no checks to this effect). You must also ensure that no tasks are elaborated prior to changing the mapping array.

This probably means that there is a library that is not being passed to the linker. You need to identify any library that is needed to resolve symbols references in your code, but is not in the %objectada%\aplilib folder. (Libraries in %objectada%\apilib are passed to the linker by default.) Any such library should be added to the link type library search path found in Project -> Settings -> Search.

The following is an example of a C main program that calls into Ada code. Notice the Ada runtime initialization and finalization calls that are necessary to set up an Ada runtime environment prior to calling an Ada subprogram and destroy it upon returning to C. After the source code, you'll find a list of what you would need to link in from the Ada build environment in order to be able to build the C example program.

-- Begin code example

-- Ada package with subprograms you want to call from C
package ex_hello is
procedure hello;
pragma export (c, hello, link_name=>"_hello");
end ex_hello;

with text_io;
package body ex_hello is

procedure hello is
begin
text_io.put_line ("Hello World");
end hello;

end ex_hello;

-- Dummy main program that withs the packages containing
-- subprograms you want to be able to call
with ex_hello;
procedure with_hello is
begin
null;
end with_hello;

-- C code
extern adainit();
extern adafinal();
extern hello();

void main ()
{
adainit();
hello();
adafinal();
}

-- End code examples

-- Object files needed when linking the program
%Ada_project_directory_path%\%Ada_target%\obj\elt\with_hello.obj
%ObjectAda%\lib\crtpexe.obj
%ObjectAda%\lib\rts.lib
%ObjectAda%\lib\ntstub.lib
%ObjectAda%\lib\adamain.lib
%Ada_project_directory_path%\with_hello.compopts.obj
%Ada_project_directory_path%\obj\ada\ex_hello.obj

In general, it is recommended that you build the code you're going to call as a DLL. For each data object or subprogram you intend to support, supply a pragma export of the form:

pragma Export(DLL, entity_name);

This will generate an entry in the .lib file that uses VC++ style name mangling and the cdecl calling convention. You can override the name used prior to mangling or the actual link name generated if you like, and you can also generate stdcall convention (for instance, if you want to dynamically load the DLL from visual basic).

The entities you wish to export should be declared in a package visible part, and a dummy "main" program of any name should include the packages you want in the DLL in its context clause.

In the project.settings.link tab, designate the application type as DLL.

When you now build, a main.exp, main.lib and main.dll file will be generated. If you're doing static linking from the C++ code to the DLL, include main.lib in the list of libaries to search at link time. This can be omitted if you're using loadLibrary to dynamically load the DLL.

The main of the DLL may be a dummy, but it actually serves to perform attach- time initialization of the DLL code (in addition to elaboration). Any user initialization code can be put there.

The "VC++ style" name mangling is not that associated with C++ functions (with the parameter and result types encoded in the link name) but rather that used for C - i.e. an underscore prefix (additional decoration is performed to create the names for the pointers through which the entities are accessed at runtime). The good news is that in general one doesn't have to worry about all this - simply match the 3rd (external_name) parameter of the pragma Import/Export to the corresponding C (or other language) entity name.

pragma Export(C, entity_name);

is legal, but

pragma Export(C, entity_name, external_name);

is better practice. An example would be

procedure Foo;

pragma Export (C, Foo, "foo");

which does not leave the case of the subprogram name to chance.

cmdline_batch_file_example
rem
rem **************************************


rem Set objectada for convenience
rem
set objectada=c:\program files\aonix\objectada

rem Add the bin directory to path so you can invoke executables easily
rem
set path=%path%;%objectada%\bin

rem Set up whatever environment variables you need.
rem For instance:
rem Location of your source files
rem
set srcpath="c:\sources"
set srcpath1="c:\more sources"
set srcpath2="c:\rest of sources"

rem Your working directory that will be the Ada libary
rem
set buildmaindir = "c:\buildmain"

rem Go to where you will create your new working library
rem and clean up existing library files
rem
cd %buildmaindir%
del unit.map /q
del ada.lib /q
rd xref /q /s
rd obj /q /s
rd il /q /s
rd msg /q /s
rd info /q /s
rem
rem **************************************

rem Create your Ada library and insert necessary Ada libraries into
rem your search path.
rem The Ada runtime library is automatically inserted.
rem Alternatively, you can create an ADAOPTS.SS file with this
rem info in it for adaopts to use.
rem Check out the online help for details.
rem
rem **************************************

adaopts -pi 0 %objectada%\bsp\system\
adaopts -pi 0 %objectada%\bsp\RAVEN\
adaopts -pi 0 %objectada%\extensions


rem Register all your program source files
rem
adareg %srcpath%\*.a*
adareg %srcpath1%\*.a*
adareg %srcpath2%\*.a*

rem Compile source files
rem
rem adacomp %srcpath%\*.a*
rem adarcomp %srcpath1%\*.a*
rem adacomp %srcpath2%\*.a*

rem Build the program
rem
adabuild

rem **************************************

rem To get a list of available options for any ObjectAda command,
rem type the name of the command at the DOS prompt, then press enter.
rem
rem **************************************