Mission accomplished. It was the "_cdecl". I've included it and tables are loaded perfectly!!!.

Good to know it wasnt a Win32::API bug or a bug in your DLL. I am very confused, since your pack 'J' (Perl Internal Scalar Unsigned Value)  letter is 64 bits long, yet you have a x86-32 DLL and a x86-32 Perl. Do you have one of the freak Perl builds with native 64 bit integers, but 32 bit pointers running 32 bit assembly code? I will assume that for the rest of this post.

I have some doubts about how HANDLE parameters will translate into the non-prototype calls. I've made a test with myTableCreate() and I think I should treat them as 'N' (I print the dumper for both the prototype and the non-prototype and I get $VAR1=48120369 and $VAR1=48120417, which doesn't seem bad). Furthermore, I'm not sure how they'd be packed (if they'd need to) before passing them to an API function as parameters.

 For instance:

__declspec(dllimport) bool myTableCompare(myTable lhs, myTable rhs, my
+Table* output, unsigned int *count, double relative_tolerance, double
+ absolute_tolerance)
download

Assuming BOOL=INT, which seems to work fine with the Kernel32 API BOOL Beep(long,long), the above C declaration translate into the following perl call:

my $TableComparer = new Win32::API("myDll.dll","myTableCompare", 'NNPP

+DD','I','_cdecl');
download

I'm not completely sure, because I get a segmentation fault when I call $TableComparer with the following parameters:

$count = 1;
$pointerToCount=pack('I',$count);
$RelativeTol=0.001;
$AbsTol=1.0;
my $areTheSame=$TableComparer->Call($LeftTable,$RightTable,$packedOutp
+utTable,$pointerToCount, $RelativeTol,$AbsTol);

download

Note that in this version of the code, I've passed $LeftTable and $RightTable without packing them before. I've tried to pass their J-packed versions but I still get a segmentation fault.

Do not pack $LeftTable and $RightTable. They should be 12345, not "\x12\x34....". myTable is a void * and is a HANDLE/pointer sized integer, myTable * is a void **. I saw you create $packedOutputTable from ,$outputTable with CreateTable but never checked $outputTable for null/0/false. $pointerToCount looks fine. I don't think the 2 doubles cause problems at this point.

Another doubt I have comes from the unsigned int pointer in the previous example, I have assumed that the signature is 'NNPPDD', and I've created the pointer using pack('I',$count), which I don't know whether it's right.

Correct. Any 'P' letters must be "ab\x01\x02cd" strings. Never ever 123.

PS: I'm using Windows and Cygwin, probably that's why sometimes things look a little bit MS-like and others a little bit Unix-like...

90% of my knowledge is Visual C or ActivePerl, 10% Mingw or Strawberry. 0% cygwin. I dont have a cygwin perl installed. Seg fault sounds correct for Cygwin Perl, since Cygwin Perl thinks and acts like Linux.

Can you do a print Dumper on all the parameters in "my $areTheSame=$TableComparer->Call($LeftTable,$RightTable,$packedOutputTable,$pointerToCount, $RelativeTol,$AbsTol);" before you do the Call() that crashes?

Do not pack $LeftTable and $RightTable. They should be 12345, not "\x12\x34....". myTable is a void * and is a HANDLE/pointer sized integer, myTable * is a void **. I saw you create $packedOutputTable from ,$outputTable with CreateTable but never checked $outputTable for null/0/false. $pointerToCount looks fine. I don't think the 2 doubles cause problems at this point.

Good, so I only have to work out wich letter to use in pack to pass $LeftTable and $RightTable. I'll have a go tomorrow and let you know (btw thanks again, I'm learning a lot). In reference with $packedOutputTable:

my $outputTable = $CreateTable->Call();
my $packedOutputTable = pack('J',$outputTable);
[download]

I understand that's the right way to pass a void**.

You should be able to figure it out yourself, on a x86-32 Perl, pack letter for pointer is V or L. Since a pointer is a 32 bit little endian number. J is the way I write "portable" code, since its 32 on 32 and 64 on 64, except when you have a non standard 32 bit perl with "quads"/"native 64 bit" support, which is what I think you have. Some people think that a 32 bit perl with "quads"/"native 64 bit" is a long overdue feature of perl so its not a bad thing. I would replace all the pack 'J's with pack 'L's or pack 'V's. You might want to put this in, its how Win32::API figures out what the pack letter for a pointer is

#const optimize
BEGIN {
    use Config;
    eval ' sub pointer_pack_type () { "'
    .($Config{ptrsize} == 8 ? 'Q' : 'L').
    '" }';
}
[download]

then do something like

$packednum = pack( pointer_pack_type() , 123456);
[download]

I still would like to see a Dumper() of the parameters you passed to myTableCompare. About your DLL, do you have the source code to it or not? If you have the source code for that DLL you can use a C debugger with symbols, you could figure out in about a minute why it crashed. Even without the source code to that DLL, you can figure out if it crashed inside the DLL, or Win32::API/Perl crashed from C stack corruption (the latter only happens with stdcall functions, cdecls very very rarely corrupt the C stack, but they may see garbage parameters if they are prototyped incorrectly by the caller, a wrong prototype with a stdcall is 100% fatal). Most MS DLLs, the C functions always "validate" their parameters, with SEH or IsBadReadPtr and friends, so when you pass a NULL ptr, or a "(char *)1234", they fail with GLR=ERROR_INVALID_PARAMETER, they DONT crash. Non-MS DLLs, its upto the programmer of that DLL on what to do, usually they don't do what MS does and simply crash.

If it works in C, its guaranteed that, somehow, someway, Win32::API my non-CPAN 0.69-0.71 will work. I say my non-CPAN versions because 0.68 for example, if the return type is a float, the C function is never called (bug in 0.68). If you want to see pushing Win32::API 0.68 to its limits (calling MS COM object "C++" methods), look at this thing I wrote, use C++ COM objects without any compiler, I had to runtime replace the insides of Win32::API 0.68 to pull it off.