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

  This file should be kept compatible with Python 2.3, see PEP 291.

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

/*

 * 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::CFuncPtr_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 is 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. _CallProc is then called with the 'callargs' tuple.  _CallProc first

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

  second array has 'void *' entried.

  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 CFuncPtr_call)

  - the callargs tuple (in CFuncPtr_call)

  - the 'struct argguments' 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"

#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

/*

  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 *

get_error_object(int **pspace)

{

	PyObject *dict = PyThreadState_GetDict();

	PyObject *errobj;

	static PyObject *error_object_name;

	if (dict == 0) {

		PyErr_SetString(PyExc_RuntimeError,

				"cannot get thread state");

		return NULL;

	}

	if (error_object_name == NULL) {

		error_object_name = PyString_InternFromString("ctypes.error_object");

		if (error_object_name == NULL)

			return NULL;

	}

	errobj = PyDict_GetItem(dict, error_object_name);

	if (errobj)

		Py_INCREF(errobj);

	else {

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

		if (space == NULL)

			return NULL;

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

		errobj = PyCObject_FromVoidPtr(space, PyMem_Free);

		if (errobj == NULL)

			return NULL;

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

					 errobj)) {

			Py_DECREF(errobj);

			return NULL;

		}

	}

	*pspace = (int *)PyCObject_AsVoidPtr(errobj);

	return errobj;

}

static PyObject *

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

{

	int *space;

	PyObject *errobj = get_error_object(&space);

	PyObject *result;

	if (errobj == NULL)

		return NULL;

	result = PyInt_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 = get_error_object(&space);

	if (errobj == NULL)

		return NULL;

	old_errno = space[index];

	space[index] = new_errno;

	Py_DECREF(errobj);

	return PyInt_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 TCHAR *FormatError(DWORD code)

{

	TCHAR *lpMsgBuf;

	DWORD n;

	n = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,

			  NULL,

			  code,

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

			  (LPTSTR) &lpMsgBuf,

			  0,

			  NULL);

	if (n) {

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

			--n;

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

	}

	return lpMsgBuf;

}

#ifndef DONT_USE_SEH

void SetException(DWORD code, EXCEPTION_RECORD *pr)

{

	TCHAR *lpMsgBuf;

	lpMsgBuf = FormatError(code);

	if(lpMsgBuf) {

		PyErr_SetFromWindowsErr(code);

		LocalFree(lpMsgBuf);

	} else {

		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_WindowsError,

					     "exception: access violation reading %p",

					     pr->ExceptionInformation[1]);

			else

				PyErr_Format(PyExc_WindowsError,

					     "exception: access violation writing %p",

					     pr->ExceptionInformation[1]);

			break;

		case EXCEPTION_BREAKPOINT:

			/* A breakpoint was encountered. */

			PyErr_SetString(PyExc_WindowsError,

					"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_WindowsError,

					"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_WindowsError,

					"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_WindowsError,

					"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_WindowsError,

					"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_WindowsError,

					"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_WindowsError,

					"exception: float inexact");

			break;

		case EXCEPTION_FLT_INVALID_OPERATION:

			/* This exception represents any floating-point

			   exception not included in this list. */

			PyErr_SetString(PyExc_WindowsError,

					"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_WindowsError,

					"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_WindowsError,

					"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_WindowsError,

					"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_WindowsError,

					"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_WindowsError,

					"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_WindowsError,

					"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_WindowsError,

					"exception: priviledged instruction");

			break;

		case EXCEPTION_NONCONTINUABLE_EXCEPTION:

			/* The thread attempted to continue execution after a

			   noncontinuable exception occurred. */

			PyErr_SetString(PyExc_WindowsError,

					"exception: nocontinuable");

			break;

		default:

			printf("error %d\n", code);

			PyErr_Format(PyExc_WindowsError,

				     "exception code 0x%08x",

				     code);

			break;

		}

	}

}

static DWORD HandleException(EXCEPTION_POINTERS *ptrs,

			     DWORD *pdw, EXCEPTION_RECORD *record)

{

	*pdw = ptrs->ExceptionRecord->ExceptionCode;

	*record = *ptrs->ExceptionRecord;

	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 PyInt_FromLong(hr);

}

#endif

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

PyCArgObject *

new_CArgObject(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 PyObject *

PyCArg_repr(PyCArgObject *self)

{

	char buffer[256];

	switch(self->tag) {

	case 'b':

	case 'B':

		sprintf(buffer, "<cparam '%c' (%d)>",

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

		break;

	case 'h':

	case 'H':

		sprintf(buffer, "<cparam '%c' (%d)>",

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

		break;

	case 'i':

	case 'I':

		sprintf(buffer, "<cparam '%c' (%d)>",

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

		break;

	case 'l':

	case 'L':

		sprintf(buffer, "<cparam '%c' (%ld)>",

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

		break;

#ifdef HAVE_LONG_LONG

	case 'q':

	case 'Q':

		sprintf(buffer,

#ifdef MS_WIN32

			"<cparam '%c' (%I64d)>",

#else

			"<cparam '%c' (%qd)>",

#endif

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

		break;

#endif

	case 'd':

		sprintf(buffer, "<cparam '%c' (%f)>",

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

		break;

	case 'f':

		sprintf(buffer, "<cparam '%c' (%f)>",

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

		break;

	case 'c':

		sprintf(buffer, "<cparam '%c' (%c)>",

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

		break;

/* 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':

		sprintf(buffer, "<cparam '%c' (%p)>",

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

		break;

	default:

		sprintf(buffer, "<cparam '%c' at %p>",

			self->tag, self);

		break;

	}

	return PyString_FromString(buffer);

}

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_compare */

	(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 */