/*

* History: First version dated from 3/97, derived from my SCMLIB version

* for win16.

*/

/*

* Related Work:

* - calldll http://www.nightmare.com/software.html

* - libffi http://sourceware.cygnus.com/libffi/

* - ffcall http://clisp.cons.org/~haible/packages-ffcall.html

* and, of course, Don Beaudry's MESS package, but this is more ctypes

* related.

*/

/*

How are functions called, and how are parameters converted to C ?

1. _ctypes.c::PyCFuncPtr_call receives an argument tuple 'inargs' and a

keyword dictionary 'kwds'.

2. After several checks, _build_callargs() is called which returns another

tuple 'callargs'. This may be the same tuple as 'inargs', a slice of

'inargs', or a completely fresh tuple, depending on several things (is it a

COM method?, are 'paramflags' available?).

3. _build_callargs also calculates bitarrays containing indexes into

the callargs tuple, specifying how to build the return value(s) of

the function.

4. _ctypes_callproc is then called with the 'callargs' tuple. _ctypes_callproc first

allocates two arrays. The first is an array of 'struct argument' items, the

second array has 'void *' entries.

5. If 'converters' are present (converters is a sequence of argtypes'

from_param methods), for each item in 'callargs' converter is called and the

result passed to ConvParam. If 'converters' are not present, each argument

is directly passed to ConvParm.

6. For each arg, ConvParam stores the contained C data (or a pointer to it,

for structures) into the 'struct argument' array.

7. Finally, a loop fills the 'void *' array so that each item points to the

data contained in or pointed to by the 'struct argument' array.

8. The 'void *' argument array is what _call_function_pointer

expects. _call_function_pointer then has very little to do - only some

libffi specific stuff, then it calls ffi_call.

So, there are 4 data structures holding processed arguments:

- the inargs tuple (in PyCFuncPtr_call)

- the callargs tuple (in PyCFuncPtr_call)

- the 'struct arguments' array

- the 'void *' array

*/

#include "Python.h"

#include "structmember.h"

#ifdef MS_WIN32

#include <windows.h>

#include <tchar.h>

#else

#include "ctypes_dlfcn.h"

#endif

#ifdef MS_WIN32

#include <malloc.h>

#endif

#include <ffi.h>

#include "ctypes.h"

#ifdef HAVE_ALLOCA_H

/* AIX needs alloca.h for alloca() */

#include <alloca.h>

#endif

#ifdef _Py_MEMORY_SANITIZER

#include <sanitizer/msan_interface.h>

#endif

#if defined(_DEBUG) || defined(__MINGW32__)

/* Don't use structured exception handling on Windows if this is defined.

MingW, AFAIK, doesn't support it.

*/

#define DONT_USE_SEH

#endif

#define CTYPES_CAPSULE_NAME_PYMEM "_ctypes pymem"

static void pymem_destructor(PyObject *ptr)

{

void *p = PyCapsule_GetPointer(ptr, CTYPES_CAPSULE_NAME_PYMEM);

if (p) {

PyMem_Free(p);

}

}

/*

ctypes maintains thread-local storage that has space for two error numbers:

private copies of the system 'errno' value and, on Windows, the system error code

accessed by the GetLastError() and SetLastError() api functions.

Foreign functions created with CDLL(..., use_errno=True), when called, swap

the system 'errno' value with the private copy just before the actual

function call, and swapped again immediately afterwards. The 'use_errno'

parameter defaults to False, in this case 'ctypes_errno' is not touched.

On Windows, foreign functions created with CDLL(..., use_last_error=True) or

WinDLL(..., use_last_error=True) swap the system LastError value with the

ctypes private copy.

The values are also swapped immeditately before and after ctypes callback

functions are called, if the callbacks are constructed using the new

optional use_errno parameter set to True: CFUNCTYPE(..., use_errno=TRUE) or

WINFUNCTYPE(..., use_errno=True).

New ctypes functions are provided to access the ctypes private copies from

Python:

- ctypes.set_errno(value) and ctypes.set_last_error(value) store 'value' in

the private copy and returns the previous value.

- ctypes.get_errno() and ctypes.get_last_error() returns the current ctypes

private copies value.

*/

/*

This function creates and returns a thread-local Python object that has

space to store two integer error numbers; once created the Python object is

kept alive in the thread state dictionary as long as the thread itself.

*/

PyObject *

_ctypes_get_errobj(int **pspace)

{

PyObject *dict = PyThreadState_GetDict();

PyObject *errobj;

static PyObject *error_object_name;

if (dict == NULL) {

PyErr_SetString(PyExc_RuntimeError,

"cannot get thread state");

return NULL;

}

if (error_object_name == NULL) {

error_object_name = PyUnicode_InternFromString("ctypes.error_object");

if (error_object_name == NULL)

return NULL;

}

errobj = PyDict_GetItem(dict, error_object_name);

if (errobj) {

if (!PyCapsule_IsValid(errobj, CTYPES_CAPSULE_NAME_PYMEM)) {

PyErr_SetString(PyExc_RuntimeError,

"ctypes.error_object is an invalid capsule");

return NULL;

}

Py_INCREF(errobj);

}

else {

void *space = PyMem_Malloc(sizeof(int) * 2);

if (space == NULL)

return NULL;

memset(space, 0, sizeof(int) * 2);

errobj = PyCapsule_New(space, CTYPES_CAPSULE_NAME_PYMEM, pymem_destructor);

if (errobj == NULL) {

PyMem_Free(space);

return NULL;

}

if (-1 == PyDict_SetItem(dict, error_object_name,

errobj)) {

Py_DECREF(errobj);

return NULL;

}

}

*pspace = (int *)PyCapsule_GetPointer(errobj, CTYPES_CAPSULE_NAME_PYMEM);

return errobj;

}

static PyObject *

get_error_internal(PyObject *self, PyObject *args, int index)

{

int *space;

PyObject *errobj = _ctypes_get_errobj(&space);

PyObject *result;

if (errobj == NULL)

return NULL;

result = PyLong_FromLong(space[index]);

Py_DECREF(errobj);

return result;

}

static PyObject *

set_error_internal(PyObject *self, PyObject *args, int index)

{

int new_errno, old_errno;

PyObject *errobj;

int *space;

if (!PyArg_ParseTuple(args, "i", &new_errno))

return NULL;

errobj = _ctypes_get_errobj(&space);

if (errobj == NULL)

return NULL;

old_errno = space[index];

space[index] = new_errno;

Py_DECREF(errobj);

return PyLong_FromLong(old_errno);

}

static PyObject *

get_errno(PyObject *self, PyObject *args)

{

return get_error_internal(self, args, 0);

}

static PyObject *

set_errno(PyObject *self, PyObject *args)

{

return set_error_internal(self, args, 0);

}

#ifdef MS_WIN32

static PyObject *

get_last_error(PyObject *self, PyObject *args)

{

return get_error_internal(self, args, 1);

}

static PyObject *

set_last_error(PyObject *self, PyObject *args)

{

return set_error_internal(self, args, 1);

}

PyObject *ComError;

static WCHAR *FormatError(DWORD code)

{

WCHAR *lpMsgBuf;

DWORD n;

n = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS,

NULL,

code,

MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */

(LPWSTR) &lpMsgBuf,

0,

NULL);

if (n) {

while (iswspace(lpMsgBuf[n-1]))

--n;

lpMsgBuf[n] = L'\0'; /* rstrip() */

}

return lpMsgBuf;

}

#ifndef DONT_USE_SEH

static void SetException(DWORD code, EXCEPTION_RECORD *pr)

{

/* The 'code' is a normal win32 error code so it could be handled by

PyErr_SetFromWindowsErr(). However, for some errors, we have additional

information not included in the error code. We handle those here and

delegate all others to the generic function. */

switch (code) {

case EXCEPTION_ACCESS_VIOLATION:

/* The thread attempted to read from or write

to a virtual address for which it does not

have the appropriate access. */

if (pr->ExceptionInformation[0] == 0)

PyErr_Format(PyExc_OSError,

"exception: access violation reading %p",

pr->ExceptionInformation[1]);

else

PyErr_Format(PyExc_OSError,

"exception: access violation writing %p",

pr->ExceptionInformation[1]);

break;

case EXCEPTION_BREAKPOINT:

/* A breakpoint was encountered. */

PyErr_SetString(PyExc_OSError,

"exception: breakpoint encountered");

break;

case EXCEPTION_DATATYPE_MISALIGNMENT:

/* The thread attempted to read or write data that is

misaligned on hardware that does not provide

alignment. For example, 16-bit values must be

aligned on 2-byte boundaries, 32-bit values on

4-byte boundaries, and so on. */

PyErr_SetString(PyExc_OSError,

"exception: datatype misalignment");

break;

case EXCEPTION_SINGLE_STEP:

/* A trace trap or other single-instruction mechanism

signaled that one instruction has been executed. */

PyErr_SetString(PyExc_OSError,

"exception: single step");

break;

case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:

/* The thread attempted to access an array element

that is out of bounds, and the underlying hardware

supports bounds checking. */

PyErr_SetString(PyExc_OSError,

"exception: array bounds exceeded");

break;

case EXCEPTION_FLT_DENORMAL_OPERAND:

/* One of the operands in a floating-point operation

is denormal. A denormal value is one that is too

small to represent as a standard floating-point

value. */

PyErr_SetString(PyExc_OSError,

"exception: floating-point operand denormal");

break;

case EXCEPTION_FLT_DIVIDE_BY_ZERO:

/* The thread attempted to divide a floating-point

value by a floating-point divisor of zero. */

PyErr_SetString(PyExc_OSError,

"exception: float divide by zero");

break;

case EXCEPTION_FLT_INEXACT_RESULT:

/* The result of a floating-point operation cannot be

represented exactly as a decimal fraction. */

PyErr_SetString(PyExc_OSError,

"exception: float inexact");

break;

case EXCEPTION_FLT_INVALID_OPERATION:

/* This exception represents any floating-point

exception not included in this list. */

PyErr_SetString(PyExc_OSError,

"exception: float invalid operation");

break;

case EXCEPTION_FLT_OVERFLOW:

/* The exponent of a floating-point operation is

greater than the magnitude allowed by the

corresponding type. */

PyErr_SetString(PyExc_OSError,

"exception: float overflow");

break;

case EXCEPTION_FLT_STACK_CHECK:

/* The stack overflowed or underflowed as the result

of a floating-point operation. */

PyErr_SetString(PyExc_OSError,

"exception: stack over/underflow");

break;

case EXCEPTION_STACK_OVERFLOW:

/* The stack overflowed or underflowed as the result

of a floating-point operation. */

PyErr_SetString(PyExc_OSError,

"exception: stack overflow");

break;

case EXCEPTION_FLT_UNDERFLOW:

/* The exponent of a floating-point operation is less

than the magnitude allowed by the corresponding

type. */

PyErr_SetString(PyExc_OSError,

"exception: float underflow");

break;

case EXCEPTION_INT_DIVIDE_BY_ZERO:

/* The thread attempted to divide an integer value by

an integer divisor of zero. */

PyErr_SetString(PyExc_OSError,

"exception: integer divide by zero");

break;

case EXCEPTION_INT_OVERFLOW:

/* The result of an integer operation caused a carry

out of the most significant bit of the result. */

PyErr_SetString(PyExc_OSError,

"exception: integer overflow");

break;

case EXCEPTION_PRIV_INSTRUCTION:

/* The thread attempted to execute an instruction

whose operation is not allowed in the current

machine mode. */

PyErr_SetString(PyExc_OSError,

"exception: privileged instruction");

break;

case EXCEPTION_NONCONTINUABLE_EXCEPTION:

/* The thread attempted to continue execution after a

noncontinuable exception occurred. */

PyErr_SetString(PyExc_OSError,

"exception: nocontinuable");

break;

default:

PyErr_SetFromWindowsErr(code);

break;

}

}

static DWORD HandleException(EXCEPTION_POINTERS *ptrs,

DWORD *pdw, EXCEPTION_RECORD *record)

{

*pdw = ptrs->ExceptionRecord->ExceptionCode;

*record = *ptrs->ExceptionRecord;

/* We don't want to catch breakpoint exceptions, they are used to attach

* a debugger to the process.

*/

if (*pdw == EXCEPTION_BREAKPOINT)

return EXCEPTION_CONTINUE_SEARCH;

return EXCEPTION_EXECUTE_HANDLER;

}

#endif

static PyObject *

check_hresult(PyObject *self, PyObject *args)

{

HRESULT hr;

if (!PyArg_ParseTuple(args, "i", &hr))

return NULL;

if (FAILED(hr))

return PyErr_SetFromWindowsErr(hr);

return PyLong_FromLong(hr);

}

#endif

/**************************************************************/

PyCArgObject *

PyCArgObject_new(void)

{

PyCArgObject *p;

p = PyObject_New(PyCArgObject, &PyCArg_Type);

if (p == NULL)

return NULL;

p->pffi_type = NULL;

p->tag = '\0';

p->obj = NULL;

memset(&p->value, 0, sizeof(p->value));

return p;

}

static void

PyCArg_dealloc(PyCArgObject *self)

{

Py_XDECREF(self->obj);

PyObject_Del(self);

}

static int

is_literal_char(unsigned char c)

{

return c < 128 && _PyUnicode_IsPrintable(c) && c != '\\' && c != '\'';

}

static PyObject *

PyCArg_repr(PyCArgObject *self)

{

switch(self->tag) {

case 'b':

case 'B':

return PyUnicode_FromFormat("<cparam '%c' (%d)>",

self->tag, self->value.b);

case 'h':

case 'H':

return PyUnicode_FromFormat("<cparam '%c' (%d)>",

self->tag, self->value.h);

case 'i':

case 'I':

return PyUnicode_FromFormat("<cparam '%c' (%d)>",

self->tag, self->value.i);

case 'l':

case 'L':

return PyUnicode_FromFormat("<cparam '%c' (%ld)>",

self->tag, self->value.l);

case 'q':

case 'Q':

return PyUnicode_FromFormat("<cparam '%c' (%lld)>",

self->tag, self->value.q);

case 'd':

case 'f': {

PyObject *f = PyFloat_FromDouble((self->tag == 'f') ? self->value.f : self->value.d);

if (f == NULL) {

return NULL;

}

PyObject *result = PyUnicode_FromFormat("<cparam '%c' (%R)>", self->tag, f);

Py_DECREF(f);

return result;

}

case 'c':

if (is_literal_char((unsigned char)self->value.c)) {

return PyUnicode_FromFormat("<cparam '%c' ('%c')>",

self->tag, self->value.c);

}

else {

return PyUnicode_FromFormat("<cparam '%c' ('\\x%02x')>",

self->tag, (unsigned char)self->value.c);

}

/* Hm, are these 'z' and 'Z' codes useful at all?

Shouldn't they be replaced by the functionality of c_string

and c_wstring ?

*/

case 'z':

case 'Z':

case 'P':

return PyUnicode_FromFormat("<cparam '%c' (%p)>",

self->tag, self->value.p);

break;

default:

if (is_literal_char((unsigned char)self->tag)) {

return PyUnicode_FromFormat("<cparam '%c' at %p>",

(unsigned char)self->tag, (void *)self);

}

else {

return PyUnicode_FromFormat("<cparam 0x%02x at %p>",

(unsigned char)self->tag, (void *)self);

}

}

}

static PyMemberDef PyCArgType_members[] = {

{ "_obj", T_OBJECT,

offsetof(PyCArgObject, obj), READONLY,

"the wrapped object" },

{ NULL },

};

PyTypeObject PyCArg_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"CArgObject",

sizeof(PyCArgObject),

0,

(destructor)PyCArg_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_reserved */

(reprfunc)PyCArg_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT, /* tp_flags */

0, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

PyCArgType_members, /* tp_members */

};

/****************************************************************/

/*

* Convert a PyObject * into a parameter suitable to pass to an

* C function call.

*

* 1. Python integers are converted to C int and passed by value.

* Py_None is converted to a C NULL pointer.

*

* 2. 3-tuples are expected to have a format character in the first

* item, which must be 'i', 'f', 'd', 'q', or 'P'.

* The second item will have to be an integer, float, double, long long

* or integer (denoting an address void *), will be converted to the

* corresponding C data type and passed by value.

*

* 3. Other Python objects are tested for an '_as_parameter_' attribute.

* The value of this attribute must be an integer which will be passed

* by value, or a 2-tuple or 3-tuple which will be used according

* to point 2 above. The third item (if any), is ignored. It is normally

* used to keep the object alive where this parameter refers to.

* XXX This convention is dangerous - you can construct arbitrary tuples

* in Python and pass them. Would it be safer to use a custom container

* datatype instead of a tuple?

*

* 4. Other Python objects cannot be passed as parameters - an exception is raised.

*

* 5. ConvParam will store the converted result in a struct containing format

* and value.

*/

union result {

char c;

char b;

short h;

int i;

long l;

long long q;

long double D;

double d;

float f;

void *p;

};

struct argument {

ffi_type *ffi_type;

PyObject *keep;

union result value;

};

/*

* Convert a single Python object into a PyCArgObject and return it.

*/

static int ConvParam(PyObject *obj, Py_ssize_t index, struct argument *pa)

{

StgDictObject *dict;

pa->keep = NULL; /* so we cannot forget it later */

dict = PyObject_stgdict(obj);

if (dict) {

PyCArgObject *carg;

assert(dict->paramfunc);

/* If it has an stgdict, it is a CDataObject */

carg = dict->paramfunc((CDataObject *)obj);

if (carg == NULL)

return -1;

pa->ffi_type = carg->pffi_type;

memcpy(&pa->value, &carg->value, sizeof(pa->value));

pa->keep = (PyObject *)carg;

return 0;

}

if (PyCArg_CheckExact(obj)) {

PyCArgObject *carg = (PyCArgObject *)obj;

pa->ffi_type = carg->pffi_type;

Py_INCREF(obj);

pa->keep = obj;

memcpy(&pa->value, &carg->value, sizeof(pa->value));

return 0;

}

/* check for None, integer, string or unicode and use directly if successful */

if (obj == Py_None) {

pa->ffi_type = &ffi_type_pointer;

pa->value.p = NULL;

return 0;

}

if (PyLong_Check(obj)) {

pa->ffi_type = &ffi_type_sint;

pa->value.i = (long)PyLong_AsUnsignedLong(obj);

if (pa->value.i == -1 && PyErr_Occurred()) {

PyErr_Clear();

pa->value.i = PyLong_AsLong(obj);

if (pa->value.i == -1 && PyErr_Occurred()) {

PyErr_SetString(PyExc_OverflowError,

"int too long to convert");

return -1;

}

}

return 0;

}

if (PyBytes_Check(obj)) {

pa->ffi_type = &ffi_type_pointer;

pa->value.p = PyBytes_AsString(obj);

Py_INCREF(obj);

pa->keep = obj;

return 0;

}

#ifdef CTYPES_UNICODE

if (PyUnicode_Check(obj)) {

pa->ffi_type = &ffi_type_pointer;

pa->value.p = PyUnicode_AsWideCharString(obj, NULL);

if (pa->value.p == NULL)

return -1;

pa->keep = PyCapsule_New(pa->value.p, CTYPES_CAPSULE_NAME_PYMEM, pymem_destructor);

if (!pa->keep) {

PyMem_Free(pa->value.p);

return -1;

}

return 0;

}

#endif

{

PyObject *arg;

arg = PyObject_GetAttrString(obj, "_as_parameter_");

/* Which types should we exactly allow here?

integers are required for using Python classes

as parameters (they have to expose the '_as_parameter_'

attribute)

*/

if (arg) {

int result;

result = ConvParam(arg, index, pa);

Py_DECREF(arg);

return result;

}

PyErr_Format(PyExc_TypeError,

"Don't know how to convert parameter %d",

Py_SAFE_DOWNCAST(index, Py_ssize_t, int));

return -1;

}

}

ffi_type *_ctypes_get_ffi_type(PyObject *obj)

{

StgDictObject *dict;

if (obj == NULL)

return &ffi_type_sint;

dict = PyType_stgdict(obj);

if (dict == NULL)

return &ffi_type_sint;

#if defined(MS_WIN32) && !defined(_WIN32_WCE)

/* This little trick works correctly with MSVC.

It returns small structures in registers

*/

if (dict->ffi_type_pointer.type == FFI_TYPE_STRUCT) {

if (can_return_struct_as_int(dict->ffi_type_pointer.size))

return &ffi_type_sint32;

else if (can_return_struct_as_sint64 (dict->ffi_type_pointer.size))

return &ffi_type_sint64;

}

#endif

return &dict->ffi_type_pointer;

}

/*

* libffi uses:

*

* ffi_status ffi_prep_cif(ffi_cif *cif, ffi_abi abi,

* unsigned int nargs,

* ffi_type *rtype,

* ffi_type **atypes);

*

* and then

*

* void ffi_call(ffi_cif *cif, void *fn, void *rvalue, void **avalues);

*/

static int _call_function_pointer(int flags,

PPROC pProc,

void **avalues,

ffi_type **atypes,

ffi_type *restype,

void *resmem,

int argcount)

{

PyThreadState *_save = NULL; /* For Py_BLOCK_THREADS and Py_UNBLOCK_THREADS */

PyObject *error_object = NULL;

int *space;

ffi_cif cif;

int cc;

#ifdef MS_WIN32

int delta;

#ifndef DONT_USE_SEH

DWORD dwExceptionCode = 0;

EXCEPTION_RECORD record;

#endif

#endif

/* XXX check before here */

if (restype == NULL) {

PyErr_SetString(PyExc_RuntimeError,

"No ffi_type for result");

return -1;

}

cc = FFI_DEFAULT_ABI;

#if defined(MS_WIN32) && !defined(MS_WIN64) && !defined(_WIN32_WCE)

if ((flags & FUNCFLAG_CDECL) == 0)

cc = FFI_STDCALL;

#endif

if (FFI_OK != ffi_prep_cif(&cif,

cc,

argcount,

restype,

atypes)) {

PyErr_SetString(PyExc_RuntimeError,

"ffi_prep_cif failed");

return -1;

}

if (flags & (FUNCFLAG_USE_ERRNO | FUNCFLAG_USE_LASTERROR)) {

error_object = _ctypes_get_errobj(&space);

if (error_object == NULL)

return -1;

}

if ((flags & FUNCFLAG_PYTHONAPI) == 0)

Py_UNBLOCK_THREADS

if (flags & FUNCFLAG_USE_ERRNO) {

int temp = space[0];

space[0] = errno;

errno = temp;

}

#ifdef MS_WIN32

if (flags & FUNCFLAG_USE_LASTERROR) {

int temp = space[1];

space[1] = GetLastError();

SetLastError(temp);

}

#ifndef DONT_USE_SEH

__try {

#endif

delta =

#endif

ffi_call(&cif, (void *)pProc, resmem, avalues);

#ifdef MS_WIN32

#ifndef DONT_USE_SEH

}

__except (HandleException(GetExceptionInformation(),

&dwExceptionCode, &record)) {

;

}

#endif

if (flags & FUNCFLAG_USE_LASTERROR) {

int temp = space[1];

space[1] = GetLastError();

SetLastError(temp);

}

#endif

if (flags & FUNCFLAG_USE_ERRNO) {

int temp = space[0];

space[0] = errno;

errno = temp;

}

if ((flags & FUNCFLAG_PYTHONAPI) == 0)

Py_BLOCK_THREADS

Py_XDECREF(error_object);

#ifdef MS_WIN32

#ifndef DONT_USE_SEH

if (dwExceptionCode) {

SetException(dwExceptionCode, &record);

return -1;

}

#endif

#ifdef MS_WIN64

if (delta != 0) {

PyErr_Format(PyExc_RuntimeError,

"ffi_call failed with code %d",

delta);

return -1;

}

#else

if (delta < 0) {

if (flags & FUNCFLAG_CDECL)

PyErr_Format(PyExc_ValueError,

"Procedure called with not enough "

"arguments (%d bytes missing) "

"or wrong calling convention",

-delta);

else

PyErr_Format(PyExc_ValueError,

"Procedure probably called with not enough "

"arguments (%d bytes missing)",

-delta);

return -1;

} else if (delta > 0) {

PyErr_Format(PyExc_ValueError,

"Procedure probably called with too many "

"arguments (%d bytes in excess)",

delta);

return -1;

}

#endif

#endif

if ((flags & FUNCFLAG_PYTHONAPI) && PyErr_Occurred())

return -1;

return 0;

}

/*

* Convert the C value in result into a Python object, depending on restype.

*

* - If restype is NULL, return a Python integer.

* - If restype is None, return None.

* - If restype is a simple ctypes type (c_int, c_void_p), call the type's getfunc,

* pass the result to checker and return the result.

* - If restype is another ctypes type, return an instance of that.

* - Otherwise, call restype and return the result.

*/

static PyObject *GetResult(PyObject *restype, void *result, PyObject *checker)

{

StgDictObject *dict;

PyObject *retval, *v;

if (restype == NULL)

return PyLong_FromLong(*(int *)result);

if (restype == Py_None) {

Py_RETURN_NONE;

}

dict = PyType_stgdict(restype);

if (dict == NULL)

return PyObject_CallFunction(restype, "i", *(int *)result);

if (dict->getfunc && !_ctypes_simple_instance(restype)) {

retval = dict->getfunc(result, dict->size);

/* If restype is py_object (detected by comparing getfunc with

O_get), we have to call Py_DECREF because O_get has already

called Py_INCREF.

*/

if (dict->getfunc == _ctypes_get_fielddesc("O")->getfunc) {

Py_DECREF(retval);

}

} else

retval = PyCData_FromBaseObj(restype, NULL, 0, result);

if (!checker || !retval)

return retval;

v = PyObject_CallFunctionObjArgs(checker, retval, NULL);

if (v == NULL)

_PyTraceback_Add("GetResult", "_ctypes/callproc.c", __LINE__-2);

Py_DECREF(retval);

return v;

}

/*

* Raise a new exception 'exc_class', adding additional text to the original

* exception string.

*/

void _ctypes_extend_error(PyObject *exc_class, const char *fmt, ...)

{

va_list vargs;

PyObject *tp, *v, *tb, *s, *cls_str, *msg_str;

va_start(vargs, fmt);

s = PyUnicode_FromFormatV(fmt, vargs);

va_end(vargs);

if (!s)

return;

PyErr_Fetch(&tp, &v, &tb);

PyErr_NormalizeException(&tp, &v, &tb);

cls_str = PyObject_Str(tp);

if (cls_str) {

PyUnicode_AppendAndDel(&s, cls_str);

PyUnicode_AppendAndDel(&s, PyUnicode_FromString(": "));

if (s == NULL)

goto error;

} else

PyErr_Clear();

msg_str = PyObject_Str(v);

if (msg_str)

PyUnicode_AppendAndDel(&s, msg_str);

else {

PyErr_Clear();

PyUnicode_AppendAndDel(&s, PyUnicode_FromString("???"));

}

if (s == NULL)

goto error;

PyErr_SetObject(exc_class, s);

error:

Py_XDECREF(tp);

Py_XDECREF(v);

Py_XDECREF(tb);

Py_XDECREF(s);

}

#ifdef MS_WIN32

static PyObject *

GetComError(HRESULT errcode, GUID *riid, IUnknown *pIunk)

{

HRESULT hr;

ISupportErrorInfo *psei = NULL;

IErrorInfo *pei = NULL;

BSTR descr=NULL, helpfile=NULL, source=NULL;

GUID guid;

DWORD helpcontext=0;

LPOLESTR progid;

PyObject *obj;

LPOLESTR text;

/* We absolutely have to release the GIL during COM method calls,

otherwise we may get a deadlock!

*/

Py_BEGIN_ALLOW_THREADS

hr = pIunk->lpVtbl->QueryInterface(pIunk, &IID_ISupportErrorInfo, (void **)&psei);

if (FAILED(hr))

goto failed;

hr = psei->lpVtbl->InterfaceSupportsErrorInfo(psei, riid);

psei->lpVtbl->Release(psei);

if (FAILED(hr))

goto failed;