Perl Win32::API() return type

Can anyone give an example of how a string can be returned from a call using Win32::API() function? I need to return a string and print using $val. Please give an example if the same can be handled using pointer as return type.

use Win32::API;  
my $res = new Win32::API('abc.dll','MyFun','_argument type list_','_Return type list_')or die $^E;  
my $val= $r开发者_运维问答es->Call();   
print ($val);

The documentation for Win32::API's Call() method suggests that you must pass Call() a scalar which will be used as a buffer to store the returned value; Call() itself will return whether the call succeeded or not.

Example:

my $return_buffer = " " x 80;
if ($res->Call(80, $return_buffer)) {
    print "OK, the API call returned '$return_buffer'\n";
} else {
    print "The API call failed for some reason.\n";
}

EDIT: quoting from the docs for completeness:

The two parameters needed here are the length of the buffer that will hold the returned temporary path, and a pointer to the buffer itself. For numerical parameters, you can use either a constant expression or a variable, while for pointers you must use a variable name (no Perl references, just a plain variable name). Also note that memory must be allocated before calling the function, just like in C. For example, to pass a buffer of 80 characters to GetTempPath(), it must be initialized before with:

$lpBuffer = " " x 80;

This allocates a string of 80 characters. If you don't do so, you'll probably get Runtime exception errors, and generally nothing will work. The call should therefore include:

$lpBuffer = " " x 80;
$GetTempPath->Call(80, $lpBuffer);

And the result will be stored in the $lpBuffer variable. Note that you don't need to pass a reference to the variable (eg. you don't need \$lpBuffer), even if its value will be set by the function.

I don't see any obvious problem with the way you are doing this. The Win32::API module is capable of receiving a char * from a DLL function and transforming it into a Perl scalar. This code, for example, does what I expect:

use Win32::API;
$GetCommandLine = Win32::API->new('kernel32',
                                  'LPTSTR GetCommandLine()');
$val = $GetCommandLine->Call();
print "The command line of this program is: $val\n";

which is to print

The command line of this program is: C:\strawberry\perl\bin\perl.exe win32-api-string.pl

The obvious things are to check the return values as well as $! and $^E from every step of your code and that abc.dll is in your program's $PATH. You might want to drop the .dll from the function call (just say Win32::API->new('abc', ...) ) -- none of the examples ever explicitly include the .dll extension, and perhaps the module assumes that you won't use it (and will try to load a library from abc.dll.dll instead).

You also might want to try using the Win32::API constructor from a prototype, as I have done in my example. I find that this gives me fewer headaches setting the right argument and return types properly (but occasionally more headaches trying to shoe horn some object type into the list of types that Win32::API supports out of the box). (The parameter list style constructor is now deprecated anyway, according to the v0.59 docs).