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

#include "ctypes_dlfcn.h"

#include "ctypes.h"

PyObject *PyExc_ArgError = NULL;

PyObject *_ctypes_ptrtype_cache = NULL;

static PyTypeObject Simple_Type;

static PyObject *_unpickle;

typedef struct {

PyObject_HEAD

PyObject *key;

PyObject *dict;

} DictRemoverObject;

static void

_DictRemover_dealloc(PyObject *myself)

{

DictRemoverObject *self = (DictRemoverObject *)myself;

Py_XDECREF(self->key);

Py_XDECREF(self->dict);

PyTypeObject *type = Py_GetType(self);

type->tp_free(myself);

Py_DECREF(type);

}

static PyObject *

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

{

DictRemoverObject *self = (DictRemoverObject *)myself;

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

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

/* XXX Error context */

PyErr_WriteUnraisable(Py_None);

Py_CLEAR(self->key);

Py_CLEAR(self->dict);

}

Py_RETURN_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_reserved */

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

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

};

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

{

PyObject *obj;

DictRemoverObject *remover;

PyObject *proxy;

int result;

obj = _PyObject_CallNoArg((PyObject *)&DictRemover_Type);

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_GetItemRef(dict, key);

if (item == NULL)

return NULL;

if (!PyWeakref_CheckProxy(item)) {

result = item;

} else {

result = PyWeakref_GET_OBJECT(item);

if (result == Py_None)

result = NULL;

}

Py_DECREF(item);

return result;

}

static char *

_ctypes_alloc_format_string_for_type(char code, int big_endian)

{

char *result;

char pep_code = '\0';

switch (code) {

#if SIZEOF_INT == 2

case 'i': pep_code = 'h'; break;

case 'I': pep_code = 'H'; break;

#elif SIZEOF_INT == 4

case 'i': pep_code = 'i'; break;

case 'I': pep_code = 'I'; break;

#elif SIZEOF_INT == 8

case 'i': pep_code = 'q'; break;

case 'I': pep_code = 'Q'; break;

# error SIZEOF_INT has an unexpected value

#endif /* SIZEOF_INT */

#if SIZEOF_LONG == 4

case 'l': pep_code = 'l'; break;

case 'L': pep_code = 'L'; break;

#elif SIZEOF_LONG == 8

case 'l': pep_code = 'q'; break;

case 'L': pep_code = 'Q'; break;

# error SIZEOF_LONG has an unexpected value

#endif /* SIZEOF_LONG */

#if SIZEOF__BOOL == 1

case '?': pep_code = '?'; break;

#elif SIZEOF__BOOL == 2

case '?': pep_code = 'H'; break;

#elif SIZEOF__BOOL == 4

case '?': pep_code = 'L'; break;

#elif SIZEOF__BOOL == 8

case '?': pep_code = 'Q'; break;

# error SIZEOF__BOOL has an unexpected value

#endif /* SIZEOF__BOOL */

default:

/* The standard-size code is the same as the ctypes one */

pep_code = code;

break;

}

result = PyMem_Malloc(3);

if (result == NULL)

return NULL;

result[0] = big_endian ? '>' : '<';

result[1] = pep_code;

result[2] = '\0';

return result;

}

char *

_ctypes_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) {

PyErr_NoMemory();

return NULL;

}

if (prefix)

strcpy(result, prefix);

else

result[0] = '\0';

strcat(result, suffix);

return result;

}

char *

_ctypes_alloc_format_string_with_shape(int ndim, const Py_ssize_t *shape,

const char *prefix, const char *suffix)

{

char *new_prefix;

char *result;

char buf[32];

Py_ssize_t prefix_len;

int k;

prefix_len = 32 * ndim + 3;

if (prefix)

prefix_len += strlen(prefix);

new_prefix = PyMem_Malloc(prefix_len);

if (new_prefix == NULL)

return NULL;

new_prefix[0] = '\0';

if (prefix)

strcpy(new_prefix, prefix);

if (ndim > 0) {

/* Add the prefix "(shape[0],shape[1],...,shape[ndim-1])" */

strcat(new_prefix, "(");

for (k = 0; k < ndim; ++k) {

if (k < ndim-1) {

sprintf(buf, "%"PY_FORMAT_SIZE_T"d,", shape[k]);

} else {

sprintf(buf, "%"PY_FORMAT_SIZE_T"d)", shape[k]);

}

strcat(new_prefix, buf);

}

}

result = _ctypes_alloc_format_string(new_prefix, suffix);

PyMem_Free(new_prefix);

return result;

}

static PyCArgObject *

StructUnionType_paramfunc(CDataObject *self)

{

PyCArgObject *parg;

StgDictObject *stgdict;

parg = PyCArgObject_new();

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

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,

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

if (!result)

return NULL;

/* keep this for bw compatibility */

PyObject *abstract = PyDict_GetItemRefString(result->tp_dict, "_abstract_");

if (abstract) {

Py_DECREF(abstract);

return (PyObject *)result;

}

dict = (StgDictObject *)_PyObject_CallNoArg((PyObject *)&PyCStgDict_Type);

if (!dict) {

Py_DECREF(result);

return NULL;

}

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

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

Py_DECREF(result);

Py_DECREF((PyObject *)dict);

return NULL;

}

Py_SETREF(result->tp_dict, (PyObject *)dict);

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

if (dict->format == NULL) {

Py_DECREF(result);

return NULL;

}

dict->paramfunc = StructUnionType_paramfunc;

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

if (!fields) {

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

if (basedict == NULL)

return (PyObject *)result;

/* copy base dict */

if (-1 == PyCStgDict_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);

Py_DECREF(fields);

return NULL;

}

Py_DECREF(fields);

return (PyObject *)result;

}

static PyObject *

PyCStructType_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 const 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 (!PyLong_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"integer expected");

return NULL;

}

buf = (void *)PyLong_AsVoidPtr(value);

if (PyErr_Occurred())

return NULL;

return PyCData_AtAddress(type, buf);

}

static const 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)

{

PyObject *obj;

PyObject *mv;

PyObject *result;

Py_buffer *buffer;

Py_ssize_t offset = 0;

StgDictObject *dict = PyType_stgdict(type);

if (!dict) {

PyErr_SetString(PyExc_TypeError, "abstract class");

return NULL;

}

if (!PyArg_ParseTuple(args, "O|n:from_buffer", &obj, &offset))

return NULL;

mv = PyMemoryView_FromObject(obj);

if (mv == NULL)

return NULL;

buffer = PyMemoryView_GET_BUFFER(mv);

if (buffer->readonly) {

PyErr_SetString(PyExc_TypeError,

"underlying buffer is not writable");

Py_DECREF(mv);

return NULL;

}

if (!PyBuffer_IsContiguous(buffer, 'C')) {

PyErr_SetString(PyExc_TypeError,

"underlying buffer is not C contiguous");

Py_DECREF(mv);

return NULL;

}

if (offset < 0) {

PyErr_SetString(PyExc_ValueError,

"offset cannot be negative");

Py_DECREF(mv);

return NULL;

}

if (dict->size > buffer->len - offset) {

PyErr_Format(PyExc_ValueError,

"Buffer size too small "

"(%zd instead of at least %zd bytes)",

buffer->len, dict->size + offset);

Py_DECREF(mv);

return NULL;

}

result = PyCData_AtAddress(type, (char *)buffer->buf + offset);

if (result == NULL) {

Py_DECREF(mv);

return NULL;

}

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

Py_DECREF(result);

return NULL;

}

return result;

}

static const char from_buffer_copy_doc[] =

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

static PyObject *

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

static PyObject *

CDataType_from_buffer_copy(PyObject *type, PyObject *args)

{

Py_buffer buffer;

Py_ssize_t offset = 0;

PyObject *result;

StgDictObject *dict = PyType_stgdict(type);

if (!dict) {

PyErr_SetString(PyExc_TypeError, "abstract class");

return NULL;

}

if (!PyArg_ParseTuple(args, "y*|n:from_buffer_copy", &buffer, &offset))

return NULL;

if (offset < 0) {

PyErr_SetString(PyExc_ValueError,

"offset cannot be negative");

PyBuffer_Release(&buffer);

return NULL;

}

if (dict->size > buffer.len - offset) {

PyErr_Format(PyExc_ValueError,

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

buffer.len, dict->size + offset);

PyBuffer_Release(&buffer);

return NULL;

}

result = GenericPyCData_new((PyTypeObject *)type, NULL, NULL);

if (result != NULL) {

memcpy(((CDataObject *)result)->b_ptr,

(char *)buffer.buf + offset, dict->size);

}

PyBuffer_Release(&buffer);

return result;

}

static const char in_dll_doc[] =

"C.in_dll(dll, name) -> C instance\naccess a C instance in a dll";

static PyObject *

CDataType_in_dll(PyObject *type, PyObject *args)

{

PyObject *dll;

char *name;

PyObject *obj;

void *handle;

void *address;

if (!PyArg_ParseTuple(args, "Os:in_dll", &dll, &name))

return NULL;

obj = PyObject_GetAttrString(dll, "_handle");

if (!obj)

return NULL;

if (!PyLong_Check(obj)) {

PyErr_SetString(PyExc_TypeError,

"the _handle attribute of the second argument must be an integer");

Py_DECREF(obj);

return NULL;

}

handle = (void *)PyLong_AsVoidPtr(obj);

Py_DECREF(obj);

if (PyErr_Occurred()) {

PyErr_SetString(PyExc_ValueError,

"could not convert the _handle attribute to a pointer");

return NULL;

}

#ifdef MS_WIN32

address = (void *)GetProcAddress(handle, name);

if (!address) {

PyErr_Format(PyExc_ValueError,

"symbol '%s' not found",

name);

return NULL;

}

address = (void *)ctypes_dlsym(handle, name);

if (!address) {

#ifdef __CYGWIN__

PyErr_Format(PyExc_ValueError,

"symbol '%s' not found",

name);

PyErr_SetString(PyExc_ValueError, ctypes_dlerror());

return NULL;

}

return PyCData_AtAddress(type, address);

}

static const char from_param_doc[] =

"Convert a Python object into a function call parameter.";

static PyObject *

CDataType_from_param(PyObject *type, PyObject *value)

{

PyObject *as_parameter;

int res = PyObject_IsInstance(value, type);

if (res == -1)

return NULL;

if (res) {

Py_INCREF(value);

return value;

}

if (PyCArg_CheckExact(value)) {

PyCArgObject *p = (PyCArgObject *)value;

PyObject *ob = p->obj;

StgDictObject *dict;

dict = PyType_stgdict(type);

/* If we got a PyCArgObject, we must check if the object packed in it

if(dict && ob) {

res = PyObject_IsInstance(ob, dict->proto);

if (res == -1)

return NULL;

if (res) {

Py_INCREF(value);

return value;

}

}

PyErr_Format(PyExc_TypeError,

"expected %s instance instead of pointer to %T",

((PyTypeObject *)type)->tp_name, ob);

return NULL;

}

as_parameter = PyObject_GetAttrString(value, "_as_parameter_");

if (as_parameter) {

value = CDataType_from_param(type, as_parameter);

Py_DECREF(as_parameter);

return value;

}

PyErr_Format(PyExc_TypeError,

"expected %s instance instead of %T",

((PyTypeObject *)type)->tp_name,

value);

return NULL;

}

static PyMethodDef CDataType_methods[] = {

{ "from_param", CDataType_from_param, METH_O, from_param_doc },

{ "from_address", CDataType_from_address, METH_O, from_address_doc },

{ "from_buffer", CDataType_from_buffer, METH_VARARGS, from_buffer_doc, },

{ "from_buffer_copy", CDataType_from_buffer_copy, METH_VARARGS, from_buffer_copy_doc, },

{ "in_dll", CDataType_in_dll, METH_VARARGS, in_dll_doc },

{ NULL, NULL },

};

static PyObject *

CDataType_repeat(PyObject *self, Py_ssize_t length)

{

if (length < 0)

return PyErr_Format(PyExc_ValueError,

"Array length must be >= 0, not %zd",

length);

return PyCArrayType_from_ctype(self, length);

}

static PySequenceMethods CDataType_as_sequence = {

0, /* inquiry sq_length; */

0, /* binaryfunc sq_concat; */

CDataType_repeat, /* intargfunc sq_repeat; */

0, /* intargfunc sq_item; */

0, /* intintargfunc sq_slice; */

0, /* intobjargproc sq_ass_item; */

0, /* intintobjargproc sq_ass_slice; */

0, /* objobjproc sq_contains; */

0, /* binaryfunc sq_inplace_concat; */

0, /* intargfunc sq_inplace_repeat; */

};

static int

CDataType_clear(PyTypeObject *self)

{

StgDictObject *dict = PyType_stgdict((PyObject *)self);

if (dict)

Py_CLEAR(dict->proto);

return PyType_Type.tp_clear((PyObject *)self);

}

static int

CDataType_traverse(PyTypeObject *self, visitproc visit, void *arg)

{

StgDictObject *dict = PyType_stgdict((PyObject *)self);

if (dict)

Py_VISIT(dict->proto);

return PyType_Type.tp_traverse((PyObject *)self, visit, arg);

}

static int

PyCStructType_setattro(PyObject *self, PyObject *key, PyObject *value)

{

/* XXX Should we disallow deleting _fields_? */

if (-1 == PyType_Type.tp_setattro(self, key, value))

return -1;

if (value && PyUnicode_Check(key) &&

_PyUnicode_EqualToASCIIString(key, "_fields_"))

return PyCStructUnionType_update_stgdict(self, value, 1);

return 0;

}

static int

UnionType_setattro(PyObject *self, PyObject *key, PyObject *value)

{

/* XXX Should we disallow deleting _fields_? */

if (-1 == PyObject_GenericSetAttr(self, key, value))

return -1;

if (PyUnicode_Check(key) &&

_PyUnicode_EqualToASCIIString(key, "_fields_"))

return PyCStructUnionType_update_stgdict(self, value, 0);

return 0;

}

PyTypeObject PyCStructType_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_ctypes.PyCStructType", /* tp_name */

0, /* tp_basicsize */

0, /* tp_itemsize */

0, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_reserved */

0, /* tp_repr */

0, /* tp_as_number */

&CDataType_as_sequence, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

PyCStructType_setattro, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */

"metatype for the CData Objects", /* tp_doc */

(traverseproc)CDataType_traverse, /* tp_traverse */

(inquiry)CDataType_clear, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

CDataType_methods, /* 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 */

PyCStructType_new, /* tp_new */

0, /* tp_free */

};

static PyTypeObject UnionType_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_ctypes.UnionType", /* tp_name */

0, /* tp_basicsize */

0, /* tp_itemsize */

0, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_reserved */

0, /* tp_repr */

0, /* tp_as_number */

&CDataType_as_sequence, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

UnionType_setattro, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */

"metatype for the CData Objects", /* tp_doc */

(traverseproc)CDataType_traverse, /* tp_traverse */

(inquiry)CDataType_clear, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

CDataType_methods, /* 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 */

UnionType_new, /* tp_new */

0, /* tp_free */

};

static int

PyCPointerType_SetProto(StgDictObject *stgdict, PyObject *proto)

{

if (!proto || !PyType_Check(proto)) {

PyErr_SetString(PyExc_TypeError,

"_type_ must be a type");

return -1;

}

if (!PyType_stgdict(proto)) {

PyErr_SetString(PyExc_TypeError,

"_type_ must have storage info");

return -1;

}

Py_INCREF(proto);

Py_XSETREF(stgdict->proto, proto);

return 0;

}

static PyCArgObject *

PyCPointerType_paramfunc(CDataObject *self)

{

PyCArgObject *parg;

parg = PyCArgObject_new();

if (parg == NULL)

return NULL;

parg->tag = 'P';

parg->pffi_type = &ffi_type_pointer;

Py_INCREF(self);

parg->obj = (PyObject *)self;

parg->value.p = *(void **)self->b_ptr;

return parg;

}

static PyObject *

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

{

PyTypeObject *result;

StgDictObject *stgdict;

PyObject *proto;

PyObject *typedict;

typedict = PyTuple_GetItemRef(args, 2);

if (!typedict) {

return NULL;

}

stgdict = (StgDictObject *)PyObject_CallObject(

(PyObject *)&PyCStgDict_Type, NULL);

if (!stgdict) {

Py_DECREF(typedict);

return NULL;

}

stgdict->size = sizeof(void *);

stgdict->align = _ctypes_get_fielddesc("P")->pffi_type->alignment;

stgdict->length = 1;

stgdict->ffi_type_pointer = ffi_type_pointer;

stgdict->paramfunc = PyCPointerType_paramfunc;

stgdict->flags |= TYPEFLAG_ISPOINTER;

proto = PyDict_GetItemRefString(typedict, "_type_");

Py_DECREF(typedict);

if (proto && -1 == PyCPointerType_SetProto(stgdict, proto)) {

Py_DECREF((PyObject *)stgdict);

Py_DECREF(proto);

return NULL;