Sweden-Number/programs/winetest/wine.xs

544 lines
19 KiB
Plaintext

/* -*-C-*-
* Perl gateway to wine API calls
*
* Copyright 2001 John F Sturtz for Codeweavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include "windef.h"
#include <EXTERN.h>
#include <perl.h>
#include <XSUB.h>
#undef WORD
#include "winbase.h"
/* API return type constants */
enum ret_type
{
RET_VOID = 0,
RET_INT = 1,
RET_WORD = 2,
RET_PTR = 3,
RET_STR = 4
};
/* max arguments for a function call */
#define MAX_ARGS 16
extern unsigned long perl_call_wine
(
FARPROC function,
int n_args,
unsigned long *args,
unsigned int *last_error,
int debug
);
/* Thunk type definitions */
#ifdef __i386__
#pragma pack(1)
struct thunk
{
BYTE pushl;
BYTE movl[2];
BYTE leal_args[3];
BYTE pushl_args;
BYTE pushl_addr;
BYTE *args_ptr;
BYTE pushl_nb_args;
BYTE nb_args;
BYTE pushl_ref;
SV *code_ref;
BYTE call;
void *func;
BYTE leave;
BYTE ret;
short arg_size;
BYTE arg_types[MAX_ARGS];
};
#pragma pack(4)
#else
#error You must implement the callback thunk for your CPU
#endif
/*--------------------------------------------------------------
| This contains most of the machine instructions necessary to
| implement the thunk. All the thunk does is turn around and
| call function callback_bridge(), which is defined in
| winetest.c.
|
| The data from this static thunk can just be copied directly
| into the thunk allocated dynamically below. That fills in
| most of it, but a couple values need to be filled in after
| the allocation, at run time:
|
| 1) The pointer to the thunk's data area, which we
| don't know yet, because we haven't allocated it
| yet ...
|
| 2) The address of the function to call. We know the
| address of the function [callback_bridge()], but
| the value filled into the thunk is an address
| relative to the thunk itself, so we can't fill it
| in until we've allocated the actual thunk.
--------------------------------------------------------------*/
static const struct thunk thunk_template =
{
/* pushl %ebp */ 0x55,
/* movl %esp,%ebp */ { 0x89, 0xe5 },
/* leal 8(%ebp),%edx */ { 0x8d, 0x55, 0x08 },
/* pushl %edx */ 0x52,
/* pushl (data addr) */ 0x68, NULL,
/* pushl (nb_args) */ 0x6a, 0,
/* pushl (code ref) */ 0x68, NULL,
/* call (func) */ 0xe8, NULL,
/* leave */ 0xc9,
/* ret $arg_size */ 0xc2, 0,
/* arg_types */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
/*----------------------------------------------------------------------
| Function: convert_value |
| -------------------------------------------------------------------- |
| Purpose: Convert a C value to a Perl value |
| |
| Parameters: type -- constant specifying type of value |
| val -- value to convert |
| |
| Returns: Perl SV * |
----------------------------------------------------------------------*/
static SV *convert_value( enum ret_type type, unsigned long val )
{
switch (type)
{
case RET_VOID: return &PL_sv_undef;
case RET_INT: return sv_2mortal( newSViv ((int) val ));
case RET_WORD: return sv_2mortal( newSViv ((int) val & 0xffff ));
case RET_PTR: return sv_2mortal( newSViv ((int) val ));
case RET_STR: return sv_2mortal( newSVpv ((char *) val, 0 ));
}
croak ("Bad return type %d", type);
return &PL_sv_undef;
}
/*----------------------------------------------------------------------
| Function: callback_bridge |
| -------------------------------------------------------------------- |
| Purpose: Central pass-through point for Wine API callbacks |
| |
| Wine API callback thunks are set up so that they call this |
| function, which turns around and calls the user's declared |
| Perl callback sub. |
| |
| Parameters: data -- pointer to thunk data area |
| args -- array of args passed from Wine API to callback |
| |
| Returns: Whatever the Perl sub returns |
----------------------------------------------------------------------*/
static int callback_bridge( SV *callback_ref, int nb_args, BYTE arg_types[], unsigned long args[] )
{
/* Locals */
int i, n;
SV *sv;
int r = 0;
/* Perl/C interface voodoo */
dSP;
ENTER;
SAVETMPS;
PUSHMARK(sp);
/* Push args on stack, according to type */
for (i = 0; i < nb_args; i++)
{
sv = convert_value (arg_types[i], args[i]);
PUSHs (sv);
}
PUTBACK;
/* Call Perl sub */
n = perl_call_sv (callback_ref, G_SCALAR);
/* Nab return value */
SPAGAIN;
if (n == 1)
{
r = POPi;
}
PUTBACK;
FREETMPS;
LEAVE;
/* [todo] Pass through Perl sub return value */
return (r);
}
/*----------------------------------------------------------------------
| XS module |
| |
| |
----------------------------------------------------------------------*/
MODULE = wine PACKAGE = wine
# --------------------------------------------------------------------
# Function: call_wine_API
# --------------------------------------------------------------------
# Purpose: Call perl_call_wine(), which calls a wine API function
#
# Parameters: function -- API function to call
# ret_type -- return type
# debug -- debug flag
# ... -- args to pass to API function
#
# Returns: list containing 2 elements: the last error code and the
# value returned by the API function
# --------------------------------------------------------------------
void
call_wine_API(function, ret_type, debug, ...)
unsigned long function;
int ret_type;
int debug;
PROTOTYPE: $$$@
PPCODE:
/*--------------------------------------------------------------
| Begin call_wine_API
--------------------------------------------------------------*/
/* Local types */
struct arg
{
int ival;
void *pval;
};
/* Locals */
int n_fixed = 3;
int n_args = (items - n_fixed);
struct arg args[MAX_ARGS+1];
unsigned long f_args[MAX_ARGS+1];
unsigned int i, n;
unsigned int last_error = 0xdeadbeef;
char *p;
SV *sv;
unsigned long r;
if (n_args > MAX_ARGS) croak("Too many arguments");
/*--------------------------------------------------------------
| Prepare function args
--------------------------------------------------------------*/
if (debug > 1)
{
fprintf( stderr, " [wine.xs/call_wine_API()]\n");
}
for (i = 0; (i < n_args); i++)
{
sv = ST (n_fixed + i);
args[i].pval = NULL;
if (! SvOK (sv))
continue;
/*--------------------------------------------------------------
| Ref
--------------------------------------------------------------*/
if (SvROK (sv))
{
sv = SvRV (sv);
/*--------------------------------------------------------------
| Integer ref -- pass address of value
--------------------------------------------------------------*/
if (SvIOK (sv))
{
args[i].ival = SvIV (sv);
f_args[i] = (unsigned long) &(args[i].ival);
if (debug > 1)
{
fprintf( stderr, " [RV->IV] 0x%lx\n", f_args[i]);
}
}
/*--------------------------------------------------------------
| Number ref -- convert and pass address of value
--------------------------------------------------------------*/
else if (SvNOK (sv))
{
args[i].ival = (unsigned long) SvNV (sv);
f_args[i] = (unsigned long) &(args[i].ival);
if (debug > 1)
{
fprintf( stderr, " [RV->NV] 0x%lx\n", f_args[i]);
}
}
/*--------------------------------------------------------------
| String ref -- pass pointer
--------------------------------------------------------------*/
else if (SvPOK (sv))
{
f_args[i] = (unsigned long) ((char *) SvPV (sv, PL_na));
if (debug > 1)
{
fprintf( stderr, " [RV->PV] 0x%lx\n", f_args[i]);
}
}
}
/*--------------------------------------------------------------
| Scalar
--------------------------------------------------------------*/
else
{
/*--------------------------------------------------------------
| Integer -- pass value
--------------------------------------------------------------*/
if (SvIOK (sv))
{
f_args[i] = (unsigned long) SvIV (sv);
if (debug > 1)
{
fprintf( stderr, " [IV] %ld (0x%lx)\n", f_args[i], f_args[i]);
}
}
/*--------------------------------------------------------------
| Number -- convert and pass value
--------------------------------------------------------------*/
else if (SvNOK (sv))
{
f_args[i] = (unsigned long) SvNV (sv);
if (debug > 1)
{
fprintf( stderr, " [NV] %ld (0x%lx)\n", f_args[i], f_args[i]);
}
}
/*--------------------------------------------------------------
| String -- pass pointer to copy
--------------------------------------------------------------*/
else if (SvPOK (sv))
{
p = SvPV (sv, n);
if ((args[i].pval = malloc( n+2 )))
{
memcpy (args[i].pval, p, n);
((char *)(args[i].pval))[n] = 0; /* add final NULL */
((char *)(args[i].pval))[n+1] = 0; /* and another one for Unicode too */
f_args[i] = (unsigned long) args[i].pval;
if (debug > 1)
{
fprintf( stderr, " [PV] 0x%lx\n", f_args[i]);
}
}
}
}
} /* end for */
/*--------------------------------------------------------------
| Here we go
--------------------------------------------------------------*/
r = perl_call_wine( (FARPROC)function, n_args, f_args, &last_error, debug );
/*--------------------------------------------------------------
| Handle modified parameter values
|
| There are four possibilities for parameter values:
|
| 1) integer value
| 2) string value
| 3) ref to integer value
| 4) ref to string value
|
| In cases 1 and 2, the intent is that the values won't be
| modified, because they're not passed by ref. So we leave
| them alone here.
|
| In case 4, the address of the actual string buffer has
| already been passed to the wine API function, which had
| opportunity to modify it if it wanted to. So again, we
| don't have anything to do here.
|
| The case we need to handle is case 3. For integers passed
| by ref, we created a local containing the initial value,
| and passed its address to the wine API function, which
| (potentially) modified it. Now we have to copy the
| (potentially) new value back to the Perl variable passed
| in, using sv_setiv(). (Which will take fewer lines of code
| to do than it took lines of comment to describe ...)
--------------------------------------------------------------*/
for (i = 0; (i < n_args); i++)
{
sv = ST (n_fixed + i);
if (! SvOK (sv))
continue;
if (SvROK (sv) && (sv = SvRV (sv)) && SvIOK (sv))
{
sv_setiv (sv, args[i].ival);
}
}
/*--------------------------------------------------------------
| Put appropriate return value on the stack for Perl to pick
| up
--------------------------------------------------------------*/
EXTEND(SP,2);
if (last_error != 0xdeadbeef) PUSHs(sv_2mortal(newSViv(last_error)));
else PUSHs( &PL_sv_undef );
PUSHs (convert_value (ret_type, r));
/*--------------------------------------------------------------
| Free up allocated memory
--------------------------------------------------------------*/
for (i = 0; (i < n_args); i++)
{
if (args[i].pval) free(args[i].pval);
}
# --------------------------------------------------------------------
# Function: load_library
# --------------------------------------------------------------------
# Purpose: Load a Wine library
#
# Parameters: module -- module (dll) to load
#
# Returns: module handle
# --------------------------------------------------------------------
void
load_library(module)
char *module;
PROTOTYPE: $
PPCODE:
ST(0) = newSViv( (I32)LoadLibraryA(module) );
XSRETURN(1);
# --------------------------------------------------------------------
# Function: get_proc_address
# --------------------------------------------------------------------
# Purpose: Retrive a function address
#
# Parameters: module -- module handle
# --------------------------------------------------------------------
void
get_proc_address(module,func)
unsigned long module;
char *func;
PROTOTYPE: $$
PPCODE:
ST(0) = newSViv( (I32)GetProcAddress( (HMODULE)module, func ) );
XSRETURN(1);
# --------------------------------------------------------------------
# Function: alloc_thunk
# --------------------------------------------------------------------
# Purpose: Allocate a thunk for a wine API callback
#
# This is used when a Wine API function is called from Perl, and
# that API function takes a callback as one of its parameters.
#
# The Wine API function, of course, must be passed the address of
# a C function as the callback. But if the API is called from Perl,
# we want the user to be able to specify a Perl sub as the callback,
# and have control returned there each time the callback is called.
#
# This function takes a code ref to a Perl sub as one of its
# arguments. It then creates a unique C function (a thunk) on the
# fly, which can be passed to the Wine API function as its callback.
#
# The thunk has its own data area (as thunks are wont to do); one
# of the things stashed there is aforementioned Perl code ref. So
# the sequence of events is as follows:
#
# 1) From Perl, user calls alloc_callback(), passing a ref
# to a Perl sub to use as the callback.
#
# 2) alloc_callback() calls this routine. This routine
# creates a thunk, and stashes the above code ref in
# it. This function then returns a pointer to the thunk
# to Perl.
#
# 3) From Perl, user calls Wine API function. As the parameter
# which is supposed to be the address of the callback, the
# user passes the pointer to the thunk allocated above.
#
# 4) The Wine API function gets called. It periodically calls
# the callback, which executes the thunk.
#
# 5) Each time the thunk is executed, it calls callback_bridge()
# (defined in winetest.c).
#
# 6) callback_bridge() fishes the Perl code ref out of the
# thunk data area and calls the Perl callback.
#
# Voila. The Perl callback gets called each time the Wine API
# function calls its callback.
#
# Parameters: [todo] Parameters ...
#
# Returns: Pointer to thunk
# --------------------------------------------------------------------
void
alloc_thunk(...)
PPCODE:
/* Locals */
struct thunk *thunk;
int i;
/* Allocate the thunk */
if (!(thunk = malloc( sizeof(*thunk) ))) croak( "Out of memory" );
(*thunk) = thunk_template;
thunk->args_ptr = thunk->arg_types;
thunk->nb_args = items - 1;
thunk->code_ref = SvRV (ST (0));
thunk->func = (void *)((char *) callback_bridge - (char *) &thunk->leave);
thunk->arg_size = thunk->nb_args * sizeof(int);
/* Stash callback arg types */
for (i = 1; i < items; i++) thunk->arg_types[i - 1] = SvIV (ST (i));
/*--------------------------------------------------------------
| Push the address of the thunk on the stack for return
|
| [todo] We need to free up the memory allocated somehow ...
--------------------------------------------------------------*/
ST (0) = newSViv ((I32) thunk);
XSRETURN (1);