Code-a-holic: November 2007

Wednesday, November 28, 2007

[Ada (GNAT/GCC)] Passing data with VB6's VARPTR to Ada

In the current project, I've been trying to figure out how to pass data to Ada. Because I'll be passing Long, Double (Float), and two Types to emulate a LongLong and a DoubleDouble, I decided I'd use VB's VarPtr and have Ada sort the mess out on its side.

After the loss of a little hair, the reading of bits of Michael B. Feldman's Software Construction and Data Structures with Ada 95, and with help from Martin Krischik and Simon Wright, I came up with the following.

The code was worked out in the context of the afore-posted api project. If you want to play with this, just take the earlier work and stuff this into it.

First up, the additions to api.ads:

   function HandlePointer (
       Left : in     Win32.LONG)
   return Win32.LONG;
   ...
   pragma Export (DLL, HandlePointer );

Next, the additions to api.adb:

   function HandlePointer (
         Left : in     Win32.LONG)
     return Win32.LONG is

      type LongRec is
         record
            L : Win32.LONG;
         end record;

      type PointerToLongRec is access LongRec;

      function Conv is
      new Unchecked_Conversion (Win32.LONG, PointerToLongRec );

      PLongRec : PointerToLongRec;
   begin
      PLongRec := Conv(Left);
      return PLongRec.All.L;
   end HandlePointer;

Next, some VB code to demonstrate ...

Declare Function handlepointer Lib "release\api.dll" (ByVal x As Long) As Long
Dim i As Long
i = 1001
Debug.Print "i="; i
Debug.Print "varptr(i)="; VarPtr(i)
Debug.Print "what ada thinks is pointed to by varptr(i)="; handlepointer(VarPtr(i))

... and a sample output.

i= 1001 
varptr(i)= 1309644 
what ada thinks is pointed to by varptr(i)= 1001 

I'm in the process now of working out how to access the LongLong and DoubleDouble Types. Shall keep you posted.

By the way, the return value will eventually be a pointer as well. That'll keep the VB programmer on his toes.

© Copyright Bruce M. Axtens, 2007

Monday, November 26, 2007

[Ada (GNAT/GCC)] Better build automation

Just after I notified comp.lang.ada of my posting re GNAT/GPL, Martin Krischik wrote suggesting I use a .gpr file and gnat make rather than a direct reference to gcc.

After reading a friendly manual, I came up with the following .grp file and a batch file to control it.

I have stayed with the batch file, simply because I can't yet see how to have a multiple-program linkage (gnatlink, dlltool and gnatlink a second time).

First, build.gpr

project Build is
 for Source_Dirs use ( "./", "c:\mingw\lib\gcc\mingw32\4.2.1\**" );
 for Object_Dir use "debug";
 for Exec_Dir use "debug";
 for Main use ("api");
     
 type Style_Type is ("debug", "release");
 Style : Style_Type := external ("STYLE", "debug");
     
 case Style is
  when "debug" =>
   for Object_Dir use "debug";
     
  when "release" =>
   for Object_Dir use "release";
   for Exec_Dir use ".";
 end case;
     
 package Builder is
     
  case Style is
   when "debug" =>
    for Default_Switches ("Ada")
    use ("-g");
    
   when others =>
    null;
  end case;
     
 end Builder;
     
 package Compiler is
     
  case Style is
   when "debug" =>
    for Default_Switches ("Ada")
     use ( "-s", 
     "-gnata",
     "-gnato",
     "-gnatE");
     
   when "release" =>
    for Default_Switches ("Ada")
     use ("-O2", "-fno-strict-aliasing");
  end case;
     
 end Compiler;
     
     end Build;

And then, build.bat. Note the call to UPX, which compresses the release version of the .DLL. Note also that the debug and release subdirectories must already exist (though it wouldn't have been difficult to check-for-and-create-if-missing.)

 @echo off
set target=%1
if %1@==@ set target=debug
if not %1@==debug@ if not %1@==release@ set target=debug

echo Building %target% version of dll
gnat make -Pbuild -XSTYLE=%target%
gnatbind -n -x %target%\api.ali -IC:\MinGW\lib\gcc\mingw32\4.2.1\stdarg -IC:\MinGW\lib\gcc\mingw32\4.2.1\win32ada
gnatlink -g -mdll -s -o %target%\api.dll %target%\api.ali -Xlinker --base-file=%target%\api.base  
dlltool --dllname api.dll --base-file %target%\api.base --output-exp %target%\api.exp --def api.def
gnatlink -g -mdll -s -o %target%\api.dll %target%\api.ali -Xlinker --base-file=%target%\api.base %target%\api.exp   

if %target%==release upx -9 %target%\api.dll

Trust that's helpful.

© Copyright Bruce M. Axtens, 2007

Friday, November 23, 2007

[Ada (GNAT/GCC)] Creating DLLs for VB6

And finally, after much prayer and perspiration, the GNAT/GCC version. Again, thanks to Roger Pearse for The Noddy Guide to using ADA code with Visual Basic. I'm sure there was someone else [This space set aside for an attribution.]

First up, api.ads, which declares the functions and exports them.

function Factorial, which accepts a Win32.LONG and returns a Win32.LONG (I gave up on C.int as it was too small for a Factorial of 16)
function GetCount, which returns the value of the global Count (another Win32.LONG)
procedure Mangle, which accepts a Win32.LPWSTR and attempts the same dangerous stuff that Bob6 does in the ObjectAda version.
function Pattern, which returns a long pointer to some string data
procedures Initialize_API, and Finalize_API, which I understand are mandatory. (If someone knows better, please tell me.)

with Interfaces.C; use Interfaces;
with Win32; use Win32;
package API is
   Count : Win32.LONG := 0;
   function Factorial (Val : Win32.LONG) return Win32.LONG;
   function GetCount return Win32.LONG;
   procedure Mangle( Ptr : Win32.LPWSTR );
   function Pattern return Win32.LPWSTR;
   
   procedure Initialize_API;
   procedure Finalize_API;

private
   pragma Export (DLL, Initialize_API);
   pragma Export (DLL, Finalize_API);
   --pragma Export (StdCall, Count);
   pragma Export (DLL, GetCount );
   pragma Export (DLL, Factorial );
   pragma Export (DLL, Mangle );
   pragma Export (DLL, Pattern );
end API;

Next, api.adb, where the declarations are explained.

I'm still working through the issue of what to do with Mangle. Perhaps two routines are needed. The first to ask the DLL how much space is needed, with VB the allocating it, and the second then actually poking the data into the allocated space.

Pattern returns a pointer to the string data. I rediscovered the technique for reading it out and that's in the VB code below. It also seems that, for as long as the DLL is loaded, the data stored in foo is available for transfer.

with Interfaces.C;
use Interfaces.C;
with Win32; use Win32;
with Win32.Winmain;
with Win32.Winbase;
with System;

package body API is
   function Factorial (Val : Win32.LONG) return Win32.LONG is
      Fact : Win32.LONG := 1;
   begin
      Count := Count + 1;
      for K in 1 .. Val loop
         Fact := Fact * K;
      end loop;
      return Fact;
   end Factorial;

   function GetCount return Win32.LONG is
   begin
      return Count;
   end GetCount;
   
   procedure Mangle( Ptr : Win32.LPWSTR ) is
      lp : Win32.lpwstr;
      foo : constant Win32.WCHAR_Array := "foo man chew" & Win32.Wide_Nul;
   begin
      lp := Win32.Winbase.lstrcpyW( Ptr, Win32.Addr(foo) );
   end Mangle;

   function Pattern return Win32.LPWSTR is
    foo : constant Win32.WCHAR_Array := "martinet mongoose manticore" & Win32.Wide_Nul;
   begin
      return Win32.Addr(foo);
   end Pattern;

   procedure Initialize_API is
      procedure Adainit;
      pragma Import (C, Adainit);
   begin
      Adainit;
   end Initialize_API;

   procedure Finalize_API is
      procedure Adafinal;
      pragma Import (C, Adafinal);
   begin
      Adafinal;
   end Finalize_API;
end API;

api.def lists the symbols exported, and is needed by gnatdll.

EXPORTS
 factorial       
 mangle
 initialize_api  
 finalize_api    
 pattern
 getcount

Now, pulling it all together requires some handwaving on the commandline. From one of the demos I modified the make.bat to look like this:

 @echo off
REM first built a relocatable Ada DLL
echo Build the Ada dll
gnat make api -IC:\MinGW\lib\gcc\mingw32\4.2.1\stdarg -IC:\MinGW\lib\gcc\mingw32\4.2.1\win32ada 
gnatbind -n -x api.ali -IC:\MinGW\lib\gcc\mingw32\4.2.1\stdarg -IC:\MinGW\lib\gcc\mingw32\4.2.1\win32ada
gnatlink -g -mdll -s -o api.dll api.ali -Xlinker --base-file=api.base
dlltool --dllname api.dll --base-file api.base --output-exp api.exp --def api.def
gnatlink -g -mdll -s -o api.dll api.ali -Xlinker --base-file=api.base api.exp

The output from a run of these is as follows:

C:\msys\1.0\home\Bruce>make
Build the Ada dll
gcc -c -IC:\MinGW\lib\gcc\mingw32\4.2.1\stdarg -IC:\MinGW\lib\gcc\mingw32\4.2.1\win32ada api.adb
Warning: resolving _finalize_api by linking to _finalize_api@0
Use --enable-stdcall-fixup to disable these warnings
Use --disable-stdcall-fixup to disable these fixups
Warning: resolving _getcount by linking to _getcount@0
Warning: resolving _initialize_api by linking to _initialize_api@0
Warning: resolving _mangle by linking to _mangle@4
Warning: resolving _pattern by linking to _pattern@0
Warning: resolving _factorial by linking to _factorial@4
C:\msys\1.0\home\Bruce>

Now the VB code. Take note of a few things:

Exporting as DLL generates decorated names, but dlltool was able to resolve the decorated ones with the undecorated ones specified in api.def
For reasons I remember reading somewhere, initialize_api and finalize_api are mandatory, and must be the first and last calls to the DLL
Seeing as woof woof woof woof is longer than foo man chew, s ends up containing foo man chew f woof
As mentioned before, I rediscovered some code for getting data from a pointer and put that in. It's the PointerToString function at the bottom.

Declare Sub initialize_api Lib "api.dll" ()
Declare Function factorial Lib "api.dll" (ByVal x As Long) As Long
Declare Function getcount Lib "api.dll" () As Long
Declare Function pattern Lib "api.dll" () As Long
Declare Sub mangle Lib "api.dll" (ByVal x As Long)
Declare Sub finalize_api Lib "api.dll" ()

' Declaration of the function which copies the character string
Private Declare Function lstrcpy Lib "Kernel32.Dll " Alias "lstrcpyW" (LpszString1 As Any, LpszString2 As Any) As Long
 
' Declaration of the function which returns the length in the character string
Private Declare Function lstrlen Lib "Kernel32.Dll " Alias "lstrlenW" (ByVal lpszString As Long) As Long
    
Sub main()
    Dim s As String
    s = "woof woof woof woof"
    initialize_api
    Dim i As Long
    For i = 1 To 16
    Debug.Print factorial(i);
    Next
    Debug.Print
    mangle StrPtr(s)
    Debug.Print Len(s), s
    Dim ptr As Long
    ptr = pattern()
    Debug.Print PointerToString(ptr)
    finalize_api
End Sub

' Converting the pointer to the character string
Function PointerToString(lngPointer As Long) As String
    Dim bytBuffer(255) As Byte
    ' Copying the character string which the pointer points to byte array
    lstrcpy bytBuffer(0), ByVal lngPointer
    ' Cutoff after the null character
    PointerToString = Left(bytBuffer, lstrlen(lngPointer))
End Function

Finally, a sample run under VB6

 1  2  6  24  120  720  5040  40320  362880  3628800  39916800  479001600  1932053504  1278945280  2004310016  2004189184 
 19           foo man chew f woof
martinet mongoose manticore

Next? Well, there's the issue of how to export overloaded functions and procedures. And there's the question of how to pass in complex data types, like records and the like. I'll keep you posted.

(By the way, I'm not doing this merely for the fun of it, but also in pursuit of the fulfillment of my employer's expectations. So more will follow.)

© Copyright Bruce M. Axtens, 2007

Thursday, November 22, 2007

[Ada (GNAT/GPL)] Creating DLLs for VB6

As promised, the GNAT/GPL code. Based on Roger Pearse's The Noddy Guide to using ADA code with Visual Basic.

How I ended up with the names api.ads, api.adb and api.def is an artefact from something I was reading. [This space set aside for an attribution.]

First up, api.ads, which declares the functions and exports them.

function Factorial, which accepts a C.int and returns a C.int
procedure Mangle, which accepts a Win32.LPWSTR and attempts the same dangerous stuff that Bob6 does in the ObjectAda version. Still working on this one.
function Pattern, which returns a Win32.LPWSTR
procedures Initialize_API, and Finalize_API, which I understand are mandatory. (If someone knows better, please tell me.)

with Interfaces.C; use Interfaces;
with Win32; use Win32;
package API is
   Count : C.int := 0;
   function Factorial (Val : C.int) return C.int;
   procedure Mangle( Ptr : Win32.LPWSTR );
   function Pattern return Win32.LPWSTR;
   procedure Initialize_API;
   procedure Finalize_API;
   --  Initialization & Finalization routines. More in the next section.
private
   pragma Export (DLL, Initialize_API);
   pragma Export (DLL, Finalize_API);
   --pragma Export (StdCall, Count);
   pragma Export (DLL, Factorial );
   pragma Export (DLL, Mangle );
   pragma Export (DLL, Pattern );
end API;

Next, api.adb, where the declarations are explained.

Mangle replaces the incoming string with something of its own. If the incoming string is larger or the same size then everything's more or less okay. (Less in the latter case, but at least it doesn't crash.) However, if the incoming string is shorter, VB truncates up to the length it knows about, and who knows what damage we've done with whatever gets overwritten by the rest of foo.

Pattern returns a pointer to the string data. Not knowing a lot about Ada, I don't know if the contents of foo will still be there by the time VB looks it and reads out.

with Interfaces.C;
use Interfaces.C;
with Win32; use Win32;
with Win32.Winmain;
with Win32.Winbase;
with System;

package body API is
   function Factorial (Val : C.int) return C.int is
      Fact : C.int := 1;
   begin
      Count := Count + 1;
      for K in 1 .. Val loop
         Fact := Fact * K;
      end loop;
      return Fact;
   end Factorial;

   procedure Mangle( Ptr : Win32.LPWSTR ) is
      lp : Win32.lpwstr;
      foo : Wide_String := Wide_String'("foo man chew");
   begin
      lp := Win32.Winbase.lstrcpyW( Ptr, Win32.Addr(foo) );
   end Mangle;

   function Pattern return Win32.LPWSTR is
    foo : Wide_String := Wide_String'("foo man chew");
   begin
      return Win32.Addr(foo);
   end Pattern;

   procedure Initialize_API is
      procedure Adainit;
      pragma Import (C, Adainit);
   begin
      Adainit;
   end Initialize_API;

   procedure Finalize_API is
      procedure Adafinal;
      pragma Import (C, Adafinal);
   begin
      Adafinal;
   end Finalize_API;
end API;

api.def lists the symbols exported, and is needed by gnatdll.

EXPORTS
 factorial       
 mangle
 initialize_api  
 finalize_api    
 pattern

Now, pulling it all together requires some handwaving on the commandline.

gnat make api -Ic:\gnat\2007\include\win32ada
gnatdll -e api.def -d api.dll api.ali -Ic:\gnat\2007\lib\win32ada

The output from a run of these is as follows:

C:\Docume...ts\BO_DLL>gnat make api -Ic:\gnat\2007\include\win32ada
gcc -c -Ic:\gnat\2007\include\win32ada api.adb
gcc -c -I.\ -Ic:\gnat\2007\include\win32ada -I- c:\gnat\2007\include\win32ada\win32.adb
gcc -c -I.\ -Ic:\gnat\2007\include\win32ada -I- c:\gnat\2007\include\win32ada\win32-winbase.adb
gcc -c -I.\ -Ic:\gnat\2007\include\win32ada -I- c:\gnat\2007\include\win32ada\win32-winmain.adb
gcc -c -I.\ -Ic:\gnat\2007\include\win32ada -I- c:\gnat\2007\include\win32ada\stdarg.adb
gcc -c -I.\ -Ic:\gnat\2007\include\win32ada -I- c:\gnat\2007\include\win32ada\stdarg-impl.adb
gcc -c -I.\ -Ic:\gnat\2007\include\win32ada -I- c:\gnat\2007\include\win32ada\win32-utils.adb
gcc -c -I.\ -Ic:\gnat\2007\include\win32ada -I- c:\gnat\2007\include\win32ada\win32-windef.adb
gcc -c -I.\ -Ic:\gnat\2007\include\win32ada -I- c:\gnat\2007\include\win32ada\win32-winnt.adb
gcc -c -I.\ -Ic:\gnat\2007\include\win32ada -I- c:\gnat\2007\include\win32ada\stdarg-machine.ads

C:\Documen...ts\BO_DLL>gnatdll -e api.def -d api.dll api.ali -Ic:\gnat\2007\lib\win32ada
Building relocatable DLL...
make api.dll and libapi.a
Warning: resolving _finalize_api by linking to _finalize_api@0
Use --enable-stdcall-fixup to disable these warnings
Use --disable-stdcall-fixup to disable these fixups
Warning: resolving _initialize_api by linking to _initialize_api@0
Warning: resolving _mangle by linking to _mangle@4
Warning: resolving _pattern by linking to _pattern@0
Warning: resolving _factorial by linking to _factorial@4
Warning: resolving _finalize_api by linking to _finalize_api@0
Use --enable-stdcall-fixup to disable these warnings
Use --disable-stdcall-fixup to disable these fixups
Warning: resolving _initialize_api by linking to _initialize_api@0
Warning: resolving _mangle by linking to _mangle@4
Warning: resolving _pattern by linking to _pattern@0
Warning: resolving _factorial by linking to _factorial@4

Now the VB code. Take note of a few things:

Exporting as DLL generates decorated names, but gnatdll was able to resolve the decorated ones with the undecorated ones specified in api.def
For reasons I remember reading somewhere, initialize_api and finalize_api are mandatory, and must be the first and last calls to the DLL
Seeing as woof woof woof woof is longer than foo man chew, s ends up containing foo man chew woof

Declare Sub initialize_api Lib "api.dll" ()
Declare Function factorial Lib "api.dll" (ByVal x As Integer) As Integer
Declare Function pattern Lib "api.dll" () As Long
Declare Sub mangle Lib "api.dll" (ByVal x As Long)
Declare Sub finalize_api Lib "api.dll" ()
Sub main()
    Dim s As String
    s = "woof woof woof woof"
    initialize_api
    Debug.Print factorial(3)
    mangle StrPtr(s)
    Debug.Print Len(s), s
    finalize_api
End Sub

Tuesday, November 20, 2007

[Ada (ObjectAda 7.2.2)] Creating VB6 DLLs

Creating DLLs for use by VB6 seems to be somewhat of a dark art. From what Roger Pearse, in his The Noddy Guide to using ADA code with Visual Basic says, it doesn't appear to be something easily achieved.

So far I've achieved it, to a certain extent, with ObjectAda and GNAT/GPL. The code for the ObjectAda implementation is below. I'll post the GNAT/GPL stuff in the next couple of days, God willing.

BO_DLib.adb, BO_D.adb and BO_D.ads are all based, albeit rather loosely, on sample files in winapi\samples\petzold\ch19\edrlib\

First up, BO_DLib.adb

-- ====================================================================================== --
--                                                                                        --
-- Converted from Programming Windows 95 / Charles Petzold -- 4th ed.                     --
-- Chapter 19 EDRLIB.C: Easy Drawing Routine Library Module                               --
--                                                                                        --
-- ====================================================================================== --

with BO_B;
procedure BO_BLib is
begin
   null;
end BO_BLib;

Next, the spec file, BO_D.ads

There are six routines:

procedure Bob1 calls dobox to show a messagebox.
function Bob2 returns a long value, 1.
function Bob3 receives a long and adds 21 to it.
procedure Bob4 receives a long pointer to a string and passes it to dobox for display.
I can pass Unicode to it and have it rendered appropriately.
function Bob5 receives a long pointer to a string and returns a long being the length of the string.
function Bob6 receives a long pointer to a string and catenates a string to it.
"Danger, Will Robinson!" ... this is not how to do it and VB complains bitterly.

Okay, there are seven routines, but dobox isn't exported. It takes a pointer to a wide string and passes it to Win32.Winuser.MessageBoxW. I got dobox from a sample file as well.

-- ====================================================================================== --
--                                                                                        --
-- Converted from Programming Windows 95 / Charles Petzold -- 4th ed.                     --
-- Chapter 19 EDRLIB.C: Easy Drawing Routine Library Module                               --
--                                                                                        --
-- ====================================================================================== --
with Win32.Windef;
package BO_B is
 procedure bob1;
 function Bob2 return Win32.LONG;
 function bob3 ( arg : Win32.LONG ) return Win32.LONG;
 procedure Bob4( Arg : win32.LPCWSTR );
 function bob5( Arg : win32.PCWSTR ) return win32.LONG;
 procedure dobox (msg : Win32.PCWSTR);
 procedure Bob6( Arg : Win32.LPWSTR );
    pragma Export (DLL_Stdcall, Bob1, "Bob1");
 pragma export (DLL_Stdcall, Bob2, "Bob2");
 pragma export (DLL_Stdcall, Bob3, "Bob3");
 pragma Export (DLL_Stdcall, Bob4, "Bob4");
 pragma Export (DLL_Stdcall, Bob5, "Bob5");
 pragma Export (DLL_Stdcall, Bob6, "Bob6");
end BO_B;

And, finally, BO_D.adb, where the definitions given in BO_D are fleshed out.

-- ====================================================================================== --
--                                                                                        --
-- Converted from Programming Windows 95 / Charles Petzold -- 4th ed.                     --
-- Chapter 19 EDRLIB.C: Easy Drawing Routine Library Module                               --
--                                                                                        --
-- ====================================================================================== --

with Interfaces.C; 
with interfaces.C.Strings;
use interfaces;
with Ada.Unchecked_Conversion;
with Interfaces.C.Strings;
with System;
with Win32.Crt.Direct;
with Win32.Crt.Stdlib;
with Win32.Winbase;
with Win32.Windef;
with Win32.Wingdi;
with Win32.Winmain;
with Win32.Utils;
with Win32.Winuser;
with win32; use win32;
with Win32.windowsx; 

package body BO_B is

procedure bob1 is
 msg : Win32.PCWSTR;
 HELLOMSG : constant WCHAR_Array := "Hello" & Wide_Nul;
begin 
 Msg := Addr(HELLOMSG);
 dobox(Msg);
end bob1;

function Bob2 return Win32.LONG is
begin
 return 1;
end bob2;

function bob3 ( arg : Win32.LONG ) return Win32.LONG is 
 use type Win32.LONG;
 sum : Win32.LONG;
begin
 Sum := Arg + 21;
 return Sum;
end Bob3;

procedure Bob4( Arg : win32.PCWSTR ) is
begin
 dobox(arg);
end Bob4;

function Bob5( Arg : win32.PCWSTR ) return win32.LONG is
 Arguments_Length : constant Win32.LONG 
  := Win32.LONG (Win32.Winbase.lstrlenW (Arg));
begin
 return Arguments_Length;
end Bob5;

procedure Bob6( Arg : Win32.LPWSTR ) is
 H : Wide_String := Wide_String'("doo dah, doo dah"); 
 c : Win32.lpwstr;
begin
 c := win32.winbase.lstrcatW( Arg, Addr(H) );
end Bob6;

procedure dobox (msg : Win32.PCWSTR) is
 IResult : Win32.INT;
begin
 iResult := Win32.Winuser.MessageBoxW(System.Null_Address, Msg, Addr("Title"), 0);
end dobox;
end BO_B;

Now the VB code. Take note of a few things:

I declared the functions and procedures as DLL_Stdcall in BO_D.ads so the routines come in decorated, thus the use of Alias in the Declare line. I used Microsoft's Dependency Walker to discover to what extent the names had been mangled.
A reference to SCRRUN.DLL was added to the project, making possible the use of the FileSystemObject.
Bob6 barges past the limit set for the string by VB, so things get a bit unstable. I'm still working through how to pass strings back.

Declare Sub Bob1 Lib "bo_blib.dll" Alias "_Bob1@0" ()
Declare Function Bob2 Lib "bo_blib.dll" Alias "_Bob2@0" () As Long
Declare Function Bob3 Lib "bo_blib.dll" Alias "_Bob3@4" (ByVal i As Long) As Long
Declare Sub Bob4 Lib "bo_blib.dll" Alias "_Bob4@4" (ByVal ptr As Long)
Declare Function Bob5 Lib "bo_blib.dll" Alias "_Bob5@4" (ByVal ptr As Long) As Long
Declare Sub Bob6 Lib "bo_blib.dll" Alias "_Bob6@4" (ByVal ptr As Long)

Dim oFSO As New Scripting.FileSystemObject
Dim oStream As Scripting.TextStream

Sub main()
    Dim s As String
    Set oStream = oFSO.OpenTextFile("c:\temp\hua.txt", ForReading, False, TristateTrue)
    s = oStream.ReadLine
    oStream.Close
    Bob1
    Debug.Print Bob2
    Debug.Print Bob3(21)
    Bob4 (StrPtr(s))
    Debug.Print Bob5(StrPtr(s))
    Bob6 StrPtr(s)
    MsgBox s
End Sub

By the way, if you think my code sucks, say so. I'm a total newb when it comes to Ada. Critiques are always welcome. King Solomon said, "The wise person accepts instructions." and also "Better is open rebuke than hidden love."

© Copyright Bruce M. Axtens., 2007