Ada equivalent to С++ header sentence.

Ada equivalent to С++ header sentence.

[Johnswort]

I try to make a binding on an API, which has a header in C++ syntax.
As a complete moron in both C/C++, I want to grab the last straw
before giving up. So I ask for a hint: what would be the Ada
equivalent to the following:

typedef BOOL                    (_stdcall T_hcConnect)(LPSTR lszCmd);

Presumingly, LPSTR may come from Win32. Just in case, VB header
translates it into

Declare Function hbConnect Lib "hapi.dll" Alias "hcConnect" (ByVal
command As String) As Long

Thank you in advance.

P.S. Yep, almost forgot: GNAT 3.15., Win2000 sp4. API comes from
HyperChem 6, if curious.

Re: Ada equivalent to С++ header sentence.

[Jeff C,]

"Johnswort" <rhezusfactor@yahoo.com> wrote in message 
news:3f27506b.0408200022.76094a5e@posting.google.com...
>I try to make a binding on an API, which has a header in C++ syntax.
> As a complete moron in both C/C++, I want to grab the last straw
> before giving up. So I ask for a hint: what would be the Ada
> equivalent to the following:
>

While I don't have a direct answer to your question I would ask that
you check to see if this DLL or some other portion of this product
has a COM/ActiveX style interface. If it does, autocreate your binding
with GNATCOM.

http://www.adapower.com/com/

(Use the latest developer snapshot).

It has not been updated in about a year but I would never consider writing
a binding to anything complex in windows if it has a COM interface
available.

Re: Ada equivalent to С++ header sentence.

[Stephen Leake]

rhezusfactor@yahoo.com (Johnswort) writes:

> I try to make a binding on an API, which has a header in C++ syntax.
> As a complete moron in both C/C++, I want to grab the last straw
> before giving up. So I ask for a hint: what would be the Ada
> equivalent to the following:
> 
> typedef BOOL                    (_stdcall T_hcConnect)(LPSTR lszCmd);

This declares T_hcConnect to be a type designating a function that
takes an LPSTR parameter and returns a BOOL result. The normal use in
C for such a type is to designate a pointer to a function. So the
equivalent in Ada is a function access type:

type T_hcConnect is access function (lszCmd : in LPSTR) return BOOL;

> Presumingly, LPSTR may come from Win32. 

Yes, it stands for "Long Pointer to String". You might be tempted to
define it in Ada as:

type LPSTR is access String; --  WRONG!

But since an Ada string is an Ada array, and a C string is just a
pointer to Char, this is wrong. You can use Interfaces.C.Pointers, but
that gets very cumbersome. Use System.Address, and make sure you
append ASCII.Nul to the end of any strings passed to C.

> Just in case, VB header translates it into
> 
> Declare Function hbConnect Lib "hapi.dll" Alias "hcConnect" (ByVal
> command As String) As Long

That's similar. But VB puts wrappers around such functions for you, so
it's not completely identical. For instance, it's not a type.

Since you appear to be importing a DLL, there are better ways than
declaring function access types. Read the GNAT user guide section on
importing DLLs. Or, as someone else pointed out, try using GNATCOM.

-- 
-- Stephe

Re: Ada equivalent to С++ header sentence.

[Frank J. Lhota]

"Stephen Leake" <stephen_leake@acm.org> wrote in message
news:mailman.5.1093005464.28011.comp.lang.ada@ada-france.org...
> rhezusfactor@yahoo.com (Johnswort) writes:
>
> > I try to make a binding on an API, which has a header in C++ syntax.
> > As a complete moron in both C/C++, I want to grab the last straw
> > before giving up. So I ask for a hint: what would be the Ada
> > equivalent to the following:
> >
> > typedef BOOL                    (_stdcall T_hcConnect)(LPSTR lszCmd);
>
> This declares T_hcConnect to be a type designating a function that
> takes an LPSTR parameter and returns a BOOL result. The normal use in
> C for such a type is to designate a pointer to a function. So the
> equivalent in Ada is a function access type:
>
> type T_hcConnect is access function (lszCmd : in LPSTR) return BOOL;
>
> > Presumingly, LPSTR may come from Win32.
>
> Yes, it stands for "Long Pointer to String". You might be tempted to
> define it in Ada as:
>
> type LPSTR is access String; --  WRONG!

The Win32 packages that come with GNAT define LPSTR, along with conversion
routines to translate between Ada Strings, C.Interfaces strings and
Win32.LPSTR.

Re: Ada equivalent to С++ header sentence.

[Johnswort]

Stephen Leake <stephen_leake@acm.org> wrote in message news:<mailman.5.1093005464.28011.comp.lang.ada@ada-france.org>...
> equivalent in Ada is a function access type:
> 
> type T_hcConnect is access function (lszCmd : in LPSTR) return BOOL;

> importing DLLs. Or, as someone else pointed out, try using GNATCOM.

Thank you all, I'll try the thing above. I like GNATCOM a lot, but
this is not the case where it's usable. Of course, I could have
written ActiveX in VB and pass it to GNATCOM, but it's a mess indeed.

And if somebody asks why not use just VB if the interface is available
- it doesnt work right all the time, which annoys me.

Re: Ada equivalent to С++ header sentence.

[Randy Brukardt]

"Stephen Leake" <stephen_leake@acm.org> wrote in message
news:mailman.5.1093005464.28011.comp.lang.ada@ada-france.org...
> rhezusfactor@yahoo.com (Johnswort) writes:
...
> > Presumingly, LPSTR may come from Win32.
>
> Yes, it stands for "Long Pointer to String". You might be tempted to
> define it in Ada as:
>
> type LPSTR is access String; --  WRONG!
>
> But since an Ada string is an Ada array, and a C string is just a
> pointer to Char, this is wrong. You can use Interfaces.C.Pointers, but
> that gets very cumbersome. Use System.Address, and make sure you
> append ASCII.Nul to the end of any strings passed to C.

I was with you until this point, but I don't agree with the advice to use
System.Address. Using it in Ada 95 (other than with an address clause)
represents a design mistake in my view.

Claw defines LPStr as
    type LPStr is access all Interfaces.C.Char;

and uses the Interfaces.C To_C and To_Ada functions to do the needed
conversions. Note that Interfaces.C.Char_Array has aliased components, so
that
    Name(Name'First)'Access
passes the first character of a Char_Array, (and thus the whole array in C
terms).

This has the advantage of being more strongly typed - it's still possible to
pass a char array that's not null terminated, but you can't accidentially
pass an array of integers or (more commonly) some record type.
Rule of thumb: Never, ever write weakly typed code when it's reasonable to
write strongly typed code.

An alternative is to use Interfaces.C.Strings (there's no reason to mess
with Interfaces.C.Pointers for this), but it tends to make you do some
storage management that's usually unnecessary. (We also didn't have it
working in Janus/Ada when we started Claw, which is probably really why we
avoided it.)

                    Randy.