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

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

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

/*

  ToDo:

  Get rid of the checker (and also the converters) field in CFuncPtrObject and

  StgDictObject, and replace them by slot functions in StgDictObject.

  think about a buffer-like object (memory? bytes?)

  Should POINTER(c_char) and POINTER(c_wchar) have a .value property?

  What about c_char and c_wchar arrays then?

  Add from_mmap, from_file, from_string metaclass methods.

  Maybe we can get away with from_file (calls read) and with a from_buffer

  method?

  And what about the to_mmap, to_file, to_str(?) methods?  They would clobber

  the namespace, probably. So, functions instead? And we already have memmove...

*/

/*

Name			methods, members, getsets

==============================================================================

StructType_Type		__new__(), from_address(), __mul__(), from_param()

UnionType_Type		__new__(), from_address(), __mul__(), from_param()

PointerType_Type	__new__(), from_address(), __mul__(), from_param(), set_type()

ArrayType_Type		__new__(), from_address(), __mul__(), from_param()

SimpleType_Type		__new__(), from_address(), __mul__(), from_param()

CData_Type

  Struct_Type		__new__(), __init__()

  Pointer_Type		__new__(), __init__(), _as_parameter_, contents

  Array_Type		__new__(), __init__(), _as_parameter_, __get/setitem__(), __len__()

  Simple_Type		__new__(), __init__(), _as_parameter_

CField_Type

StgDict_Type

==============================================================================

class methods

-------------

It has some similarity to the byref() construct compared to pointer()

from_address(addr)

	- construct an instance from a given memory block (sharing this memory block)

from_param(obj)

	- typecheck and convert a Python object into a C function call parameter

	  the result may be an instance of the type, or an integer or tuple

	  (typecode, value[, obj])

instance methods/properties

---------------------------

_as_parameter_

	- convert self into a C function call parameter

	  This is either an integer, or a 3-tuple (typecode, value, obj)

functions

---------

sizeof(cdata)

	- return the number of bytes the buffer contains

sizeof(ctype)

	- return the number of bytes the buffer of an instance would contain

byref(cdata)

addressof(cdata)

pointer(cdata)

POINTER(ctype)

bytes(cdata)

	- return the buffer contents as a sequence of bytes (which is currently a string)

*/

/*

 * StgDict_Type

 * StructType_Type

 * UnionType_Type

 * PointerType_Type

 * ArrayType_Type

 * SimpleType_Type

 *

 * CData_Type

 * Struct_Type

 * Union_Type

 * Array_Type

 * Simple_Type

 * Pointer_Type

 * CField_Type

 *

 */

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

#include <ffi.h>

#ifdef MS_WIN32

#include <windows.h>

#include <malloc.h>

#ifndef IS_INTRESOURCE

#define IS_INTRESOURCE(x) (((size_t)(x) >> 16) == 0)

#endif

# ifdef _WIN32_WCE

/* Unlike desktop Windows, WinCE has both W and A variants of

   GetProcAddress, but the default W version is not what we want */

#  undef GetProcAddress

#  define GetProcAddress GetProcAddressA

# endif

#else

#include "ctypes_dlfcn.h"

#endif

#include "ctypes.h"

PyObject *PyExc_ArgError;

/* This dict maps ctypes types to POINTER types */

PyObject *_pointer_type_cache;

static PyTypeObject Simple_Type;

/* a callable object used for unpickling */

static PyObject *_unpickle;

char *conversion_mode_encoding = NULL;

char *conversion_mode_errors = NULL;

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

#if (PY_VERSION_HEX < 0x02040000)

/* Only in Python 2.4 and up */

static PyObject *

PyTuple_Pack(int n, ...)

{

	int i;

	PyObject *o;

	PyObject *result;

	PyObject **items;

	va_list vargs;

	va_start(vargs, n);

	result = PyTuple_New(n);

	if (result == NULL)

		return NULL;

	items = ((PyTupleObject *)result)->ob_item;

	for (i = 0; i < n; i++) {

		o = va_arg(vargs, PyObject *);

		Py_INCREF(o);

		items[i] = o;

	}

	va_end(vargs);

	return result;

}

#endif

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

typedef struct {

	PyObject_HEAD

	PyObject *key;

	PyObject *dict;

} DictRemoverObject;

static void

_DictRemover_dealloc(PyObject *_self)

{

	DictRemoverObject *self = (DictRemoverObject *)_self;

	Py_XDECREF(self->key);

	Py_XDECREF(self->dict);

	Py_TYPE(self)->tp_free(_self);

}

static PyObject *

_DictRemover_call(PyObject *_self, PyObject *args, PyObject *kw)

{

	DictRemoverObject *self = (DictRemoverObject *)_self;

	if (self->key && self->dict) {

		if (-1 == PyDict_DelItem(self->dict, self->key))

			/* XXX Error context */

			PyErr_WriteUnraisable(Py_None);

		Py_DECREF(self->key);

		self->key = NULL;

		Py_DECREF(self->dict);

		self->dict = NULL;

	}

	Py_INCREF(Py_None);

	return Py_None;

}

static PyTypeObject DictRemover_Type = {

	PyVarObject_HEAD_INIT(NULL, 0)

	"_ctypes.DictRemover",			/* tp_name */

	sizeof(DictRemoverObject),		/* tp_basicsize */

	0,					/* tp_itemsize */

	_DictRemover_dealloc,			/* tp_dealloc */

	0,					/* tp_print */

	0,					/* tp_getattr */

	0,					/* tp_setattr */

	0,					/* tp_compare */

	0,			       		/* tp_repr */

	0,					/* tp_as_number */

	0,					/* tp_as_sequence */

	0,					/* tp_as_mapping */

	0,					/* tp_hash */

	_DictRemover_call,			/* tp_call */

	0,					/* tp_str */

	0,					/* tp_getattro */

	0,					/* tp_setattro */

	0,					/* tp_as_buffer */

/* XXX should participate in GC? */

	Py_TPFLAGS_DEFAULT,			/* tp_flags */

	"deletes a key from a dictionary",	/* tp_doc */

	0,					/* tp_traverse */

	0,					/* tp_clear */

	0,					/* tp_richcompare */

	0,					/* tp_weaklistoffset */

	0,					/* tp_iter */

	0,					/* tp_iternext */

	0,					/* tp_methods */

	0,					/* tp_members */

	0,					/* tp_getset */

	0,					/* tp_base */

	0,					/* tp_dict */

	0,					/* tp_descr_get */

	0,					/* tp_descr_set */

	0,					/* tp_dictoffset */

	0,					/* tp_init */

	0,					/* tp_alloc */

	0,					/* tp_new */

	0,					/* tp_free */

};

int

PyDict_SetItemProxy(PyObject *dict, PyObject *key, PyObject *item)

{

	PyObject *obj;

	DictRemoverObject *remover;

	PyObject *proxy;

	int result;

	obj = PyObject_CallObject((PyObject *)&DictRemover_Type, NULL);

	if (obj == NULL)

		return -1;

	remover = (DictRemoverObject *)obj;

	assert(remover->key == NULL);

	assert(remover->dict == NULL);

	Py_INCREF(key);

	remover->key = key;

	Py_INCREF(dict);

	remover->dict = dict;

	proxy = PyWeakref_NewProxy(item, obj);

	Py_DECREF(obj);

	if (proxy == NULL)

		return -1;

	result = PyDict_SetItem(dict, key, proxy);

	Py_DECREF(proxy);

	return result;

}

PyObject *

PyDict_GetItemProxy(PyObject *dict, PyObject *key)

{

	PyObject *result;

	PyObject *item = PyDict_GetItem(dict, key);

	if (item == NULL)

		return NULL;

	if (!PyWeakref_CheckProxy(item))

		return item;

	result = PyWeakref_GET_OBJECT(item);

	if (result == Py_None)

		return NULL;

	return result;

}

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

/*

  Allocate a memory block for a pep3118 format string, copy prefix (if

  non-null) and suffix into it.  Returns NULL on failure, with the error

  indicator set.  If called with a suffix of NULL the error indicator must

  already be set.

 */

char *

alloc_format_string(const char *prefix, const char *suffix)

{

	size_t len;

	char *result;

	if (suffix == NULL) {

		assert(PyErr_Occurred());

		return NULL;

	}

	len = strlen(suffix);

	if (prefix)

		len += strlen(prefix);

	result = PyMem_Malloc(len + 1);

	if (result == NULL)

		return NULL;

	if (prefix)

		strcpy(result, prefix);

	else

		result[0] = '\0';

	strcat(result, suffix);

	return result;

}

/*

  StructType_Type - a meta type/class.  Creating a new class using this one as

  __metaclass__ will call the contructor StructUnionType_new.  It replaces the

  tp_dict member with a new instance of StgDict, and initializes the C

  accessible fields somehow.

*/

static PyCArgObject *

StructUnionType_paramfunc(CDataObject *self)

{

	PyCArgObject *parg;

	StgDictObject *stgdict;

	parg = new_CArgObject();

	if (parg == NULL)

		return NULL;

	parg->tag = 'V';

	stgdict = PyObject_stgdict((PyObject *)self);

	assert(stgdict); /* Cannot be NULL for structure/union instances */

	parg->pffi_type = &stgdict->ffi_type_pointer;

	/* For structure parameters (by value), parg->value doesn't contain the structure

	   data itself, instead parg->value.p *points* to the structure's data

	   See also _ctypes.c, function _call_function_pointer().

	*/

	parg->value.p = self->b_ptr;

	parg->size = self->b_size;

	Py_INCREF(self);

	parg->obj = (PyObject *)self;

	return parg;	

}

static PyObject *

StructUnionType_new(PyTypeObject *type, PyObject *args, PyObject *kwds, int isStruct)

{

	PyTypeObject *result;

	PyObject *fields;

	StgDictObject *dict;

	/* create the new instance (which is a class,

	   since we are a metatype!) */

	result = (PyTypeObject *)PyType_Type.tp_new(type, args, kwds);

	if (!result)

		return NULL;

	/* keep this for bw compatibility */

	if (PyDict_GetItemString(result->tp_dict, "_abstract_"))

		return (PyObject *)result;

	dict = (StgDictObject *)PyObject_CallObject((PyObject *)&StgDict_Type, NULL);

	if (!dict) {

		Py_DECREF(result);

		return NULL;

	}

	/* replace the class dict by our updated stgdict, which holds info

	   about storage requirements of the instances */

	if (-1 == PyDict_Update((PyObject *)dict, result->tp_dict)) {

		Py_DECREF(result);

		Py_DECREF((PyObject *)dict);

		return NULL;

	}

	Py_DECREF(result->tp_dict);

	result->tp_dict = (PyObject *)dict;

	dict->format = alloc_format_string(NULL, "B");

	if (dict->format == NULL) {

		Py_DECREF(result);

		return NULL;

	}

	dict->paramfunc = StructUnionType_paramfunc;

	fields = PyDict_GetItemString((PyObject *)dict, "_fields_");

	if (!fields) {

		StgDictObject *basedict = PyType_stgdict((PyObject *)result->tp_base);

		if (basedict == NULL)

			return (PyObject *)result;

		/* copy base dict */

		if (-1 == StgDict_clone(dict, basedict)) {

			Py_DECREF(result);

			return NULL;

		}

		dict->flags &= ~DICTFLAG_FINAL; /* clear the 'final' flag in the subclass dict */

		basedict->flags |= DICTFLAG_FINAL; /* set the 'final' flag in the baseclass dict */

		return (PyObject *)result;

	}

	if (-1 == PyObject_SetAttrString((PyObject *)result, "_fields_", fields)) {

		Py_DECREF(result);

		return NULL;

	}

	return (PyObject *)result;

}

static PyObject *

StructType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

	return StructUnionType_new(type, args, kwds, 1);

}

static PyObject *

UnionType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

	return StructUnionType_new(type, args, kwds, 0);

}

static char from_address_doc[] =

"C.from_address(integer) -> C instance\naccess a C instance at the specified address";

static PyObject *

CDataType_from_address(PyObject *type, PyObject *value)

{

	void *buf;

	if (!PyInt_Check(value) && !PyLong_Check(value)) {

		PyErr_SetString(PyExc_TypeError,

				"integer expected");

		return NULL;

	}

	buf = (void *)PyLong_AsVoidPtr(value);

	if (PyErr_Occurred())

		return NULL;

	return CData_AtAddress(type, buf);

}

static char from_buffer_doc[] =

"C.from_buffer(object, offset=0) -> C instance\ncreate a C instance from a writeable buffer";

static int

KeepRef(CDataObject *target, Py_ssize_t index, PyObject *keep);

static PyObject *

CDataType_from_buffer(PyObject *type, PyObject *args)

{

	void *buffer;

	Py_ssize_t buffer_len;

	Py_ssize_t offset = 0;

	PyObject *obj, *result;

	StgDictObject *dict = PyType_stgdict(type);

	assert (dict);

	if (!PyArg_ParseTuple(args,

#if (PY_VERSION_HEX < 0x02050000)

			      "O|i:from_buffer",

#else

			      "O|n:from_buffer",

#endif

			      &obj, &offset))

		return NULL;

	if (-1 == PyObject_AsWriteBuffer(obj, &buffer, &buffer_len))

		return NULL;

	if (offset < 0) {

		PyErr_SetString(PyExc_ValueError,

				"offset cannit be negative");

		return NULL;

	}

	if (dict->size > buffer_len - offset) {

		PyErr_Format(PyExc_ValueError,

#if (PY_VERSION_HEX < 0x02050000)

			     "Buffer size too small (%d instead of at least %d bytes)",

#else

			     "Buffer size too small (%zd instead of at least %zd bytes)",

#endif

			     buffer_len, dict->size + offset);

		return NULL;

	}

	result = CData_AtAddress(type, (char *)buffer + offset);

	if (result == NULL)

		return NULL;

	Py_INCREF(obj);

	if (-1 == KeepRef((CDataObject *)result, -1, obj)) {

		Py_DECREF(result);

		return NULL;

	}

	return result;

}

static char from_buffer_copy_doc[] =

"C.from_buffer_copy(object, offset=0) -> C instance\ncreate a C instance from a readable buffer";

static PyObject *

GenericCData_new(PyTypeObject *type, PyObject *args, PyObject *kwds);

static PyObject *

CDataType_from_buffer_copy(PyObject *type, PyObject *args)

{

	const void *buffer;

	Py_ssize_t buffer_len;

	Py_ssize_t offset = 0;

	PyObject *obj, *result;

	StgDictObject *dict = PyType_stgdict(type);

	assert (dict);

	if (!PyArg_ParseTuple(args,

#if (PY_VERSION_HEX < 0x02050000)

			      "O|i:from_buffer",

#else

			      "O|n:from_buffer",

#endif

			      &obj, &offset))

		return NULL;