To judge from postings in the comp.lang.ada newsgroup, this might be an FAQ:

No-one seems to know.  Here are the results of my investigations - I am part way there.

The other alternative (advocated by AdaPower) is to create a COM object using the GNATCOM utilities from their site.  This sounds as if it might be easier than what I'm doing.

This page is the result of my own investigations into the subject. I am not an ADA  person, so this will be pretty superficial. However I think the page is necessary as the existing pages do not seem to be focused on people like myself, which means they are hard to use, however useful they may be to the guru.

This page is not kept up to date - use it with that in mind. This is simply because I have other things to do. 

• Ada Compilers - the good, the bad and the ugly
• AONIX - It can be done ... 
  • Creating and compiling a DLL with AONIX - demo
• GNAT - Not currently possible to use from VB, but here's how to compile them anyway
  • Creating and compiling a DLL with GNAT - demo
  • Modifying the demo DLL with GNAT
• Useful Web pages

It's a strange feature of the world of Ada that even vendors seem to try to keep things hidden. You can look at their web pages for ages without finding out how to get their products. So here's the details.

There are two Ada compilers:

• Aonix ObjectAda. Their web page is at www.aonix.com, although I found it a content-free experience. I actually had to email them to find out how to get hold of their products. The UK office ignored an email, and when telephoned seemed to have no idea of what to do with someone who wanted to buy something! They don't even stock the entry-level commercial product.

• GNAT. This is the freeware GNU Ada. Again there is a website for a commercial version, at https://www.gnu.org/software/gnat/. The current version was 3.11p, for NT and Win9x. This product is also available on the usual GNU UNIX platforms, although I haven't used these.

Creating and compiling a DLL with AONIX - demo

There is a demo in the help file, if you can find it.   Based on that I amended it to contain this stuff [qqq add more sometime and explain this:  The call nearly always works, but the calls with parameters are the problem.  You need to use DLL as the calling convention in the pragma - the others fail.  And you need to suppress checks.  I got that bit from the source for the AdaInit module included in the help file, which tells you that it needs to be so.]

---------------------------------- Start of File --------------------------------------
package P is

-- Header - list the procedures/functions, with their pragmas

--sub DLLProc
--------------

procedure DLLProc;
  pragma Export(DLL,DLLProc,"DLLProc");

--sub mytestfunc
----------------

function mytestfunc return integer;
  pragma Export(DLL,mytestfunc,"mytestfunc");
  pragma Suppress (All_Checks, on => mytestfunc); 

-- It doesn't get back the param without this - instead
-- you get an error (DUMP it to file!) "Runtime error '453': can't find DLL entry point mytestfunc in dll.DLL"
-- NB make sure you compile AND build! Several times I was only compiling when I thought I was building!

-- Other values that don't work that I tried:
-- pragma Export(DLL_Stdcall,mytestfunc,"mytestfunc");
-- pragma Export(ada,mytestfunc,"mytestfunc");
-- pragma Export(ada,mytestfunc,link_name => "mytestfunc");

end;      -- Of the package header
--------------------------------------------------

with Ada.Text_IO;
package body P is

-- DLL funcs and procedures here
procedure DLLProc is
    myvar : integer;
begin
    myvar := 101;
end DLLProc;
----------------------------

function mytestfunc return integer is
begin
    return 101;
end mytestfunc;
----------------------------

end P;     -- End of the package
--------------------------------------------------------

with P;
procedure DLL is
begin
   null; -- perform any initializations here
end;
-------------------------------- End of File --------------------------------------

If you need an Ada EXE to test your DLL is OK before you try calling it from VB, create a .adb containing this:

--Calling the DLL
--
procedure UseDLL is
procedure DLLProc;
pragma Import(DLL,DLLProc,"DLLProc");
begin
 DLLProc;
end;

Here's some output from the compiler for the DLL:

1. Project|Compile All Files:

--------------------Target: Win32 (Intel) Debug--------------------
standard.ada: Warning: LRM:10.1.4(5), Unable to read file C:\Roger_Big\vbinfo2\C++ and VB DLL\vbdemo\adadll2\adadll\adadll-Win32(Intel)-Debug\adadll.adb to find needed compilation unit, continuing

Front end of ..\..\adadll.adb succeeded with no errors.
obj\adb\adadll.obj
Tool execution has completed. 

2. Project|Build DLL.DLL:

--------------------Target: Win32 (Intel) Debug--------------------
ObjectAda Personal Edition version 7.1.2.806: adabuild
Copyright (c) 1997, Aonix. All Rights Reserved.
obj\elt\dll.obj
Creating library dll.lib and object dll.exp
Linking...
Link of dll completed successfully
Tool execution has completed.

So, what have I achieved?  1.  I can call a DLL from VB.  2.  I can get an integer back from it.

However, I can't pass a string, and returning a character causes a crash.  More investigation needed here.

At present the DLL's produced by GNAT can't be called from Visual Basic.  This information is here in case the situation changes.

This is not particularly complicated as such, but it's difficult to locate the information. However a simple project does exist, and here it is, thanks to Jerry van Dijk and David Marceau 3^rd June 1999, who have placed it in the public domain. Thanks also to David Botton for his help.

This is a 'noddy' DLL which contains three functions; Junk() which takes no parameters and just displays a message, Junk_2() which is the same but returns a value, and Junk_3() which is the same as _2() but takes a parameter.

There are 2 files:

• adadll.ads - This is the header file for the DLL, with the functions being exported, plus a bit of infrastructure stuff.
• adadll.adb - This is the main DLL code for each of the functions.

In order to try out the DLL, we must call it from somewhere. Here we use a little C++ program which simply calls each function in turn.

These are the files which create a tiny C++ program which can call the DLL. I used Visual C++ 2.0 to compile them, but I gather Visual C++ 6.0 SP1 also works.

• adadll.def - The DLL .def file, which contains the list of functions exported so that the Windows linker can identify them to build an import library (.LIB). This is required to use the DLL from languages like C/C++.
• client.cpp - The C++ stub for the demo program. The .LIB is linked into this. This creates an EXE called client.exe, which just calls the DLL.

To compile these a DOS batch file is used. Don't use the IDE's - do all your compiling at the command line. For MSVC this will mean running a batch file to ensure that the compiler is available at the command line. (In MSVC 2.0 you run VCVARS32.BAT from the MSVC20\BIN directory).

This requires GNAT Ada v3.11p - earlier versions will not work.

• make.bat - Compiles the DLL, creates an import library (.LIB) and compiles the client.exe (in that order).

All of these files can be downloaded from the above links - they're as small as may be.

If you want to tweak the compilation options, for debug use -g and avoid -O2 in the compiler; and avoid -s in the linker.

At the command prompt, just type

and the program will run. There is no need to 'register' the DLL - since it isn't a COM object it can't be registered anyway.

This is where it all gets difficult. Basically if you try to use that DLL which worked fine in C++, it doesn't work, and gives error 7. It seems you can only use this DLL if you call it via a .LIB file, which of course VB does not.

Opinions as to why are as follows:

David Botton:

David Marceau:

I've not experimented with compiling the DLL on NT and seeing if it worked with VB6 on that platform, as I need something that will work on Win9x.

Modifying the GNAT demo DLL

There are some points that need to be considered when you write a DLL.

1. Creating your own functions/procedures

Create ada code for these. It should be remembered that most things in windows use stdcall calling convention for calling routines in a dll, so you may have to have a line with use a

There are examples below and in the demo.

2. DLLMain()

There must be a procedure of this name, created as follows:

    --
    -- * Prototype
    --
    function DllMain (A, B, C : Integer) return Integer;
    pragma Export (StdCall, DllMain, "DllMain");
    --
    -- * Function
    --
    function DllMain (A, B, C : Integer) return Integer is
    begin
      return 1;
    end DllMain;

This function is called when the dll initialises. Leave it just like this. Usually it is not safe to call Ada code from here, because elaboration (the Ada name for execution of Library and Package Body initialisation code) has not been done at the moment the routine is called. Do not call the ada elaboration routine adainit() from it, because this will make the DLL hang if tasking (the ada built-in multi-tasking) is involved in your code.

3. AdaInit()

The AdaInit() procedure is declared as follows in the header:

      procedure AdaInit;
      pragma Import (C, AdaInit);

Make sure that you call it from a procedure of your own before any 'elaboration' (i.e. package body initialisation sections) of the ada code is required. Usually it is best to add a routine in the dll interface specifically for doing this. Note that does not matter if you call this routine more then once, because the second and subsequent calls have no effect, as may be seen from the generated code from gnatbind.

These notes derived from a page by Wiljan Derks, at http://www.adapower.com/articles/howto-gdll.html

The most useful resource is David Botton's Adapower site and in particular the article "Using GNAT Dlls from C (van Dijk & Marceau)" at http://www.adapower.com/articles/howto-gdllc.html. There is also material for the real techie on producing a COM object in Ada, inside a DLL.

There is also an Ada newsgroup - comp.lang.ada - which can be useful, particularly if you use Google Groups to search its back archive. There is no FAQ, unfortunately.

Have a look also for C++ DLL and VB.  There are some good tutorials, and many of the error messages that VB gives are the same.  Food for thought anyway.  It was after reading some of these that I felt impelled to have another go.

Constructive feedback is welcomed to Roger Pearse.

Revised 26^th October 2001.  
Revised 14^th July 1999.