#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "Python.h"

#ifdef MS_WIN32

# include <windows.h>

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_ceval.h" // _Py_EnterRecursiveCall()

#ifdef MS_WIN32

# include "pycore_modsupport.h" // _PyArg_NoKeywords()

#include "pycore_pyerrors.h" // _PyErr_WriteUnraisableMsg()

#include <ffi.h>

#ifdef MS_WIN32

#include <malloc.h>

#ifndef IS_INTRESOURCE

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

#include <dlfcn.h>

#include "ctypes.h"

#include "pycore_long.h" // _PyLong_GetZero()

ctypes_state global_state;

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 int

_DictRemover_traverse(DictRemoverObject *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->key);

Py_VISIT(self->dict);

return 0;

}

static int

_DictRemover_clear(DictRemoverObject *self)

{

Py_CLEAR(self->key);

Py_CLEAR(self->dict);

return 0;

}

static void

_DictRemover_dealloc(PyObject *myself)

{

PyTypeObject *tp = Py_TYPE(myself);

DictRemoverObject *self = (DictRemoverObject *)myself;

PyObject_GC_UnTrack(myself);

(void)_DictRemover_clear(self);

tp->tp_free(myself);

Py_DECREF(tp);

}

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

_PyErr_WriteUnraisableMsg("on calling _ctypes.DictRemover", NULL);

}

Py_CLEAR(self->key);

Py_CLEAR(self->dict);

}

Py_RETURN_NONE;

}

PyDoc_STRVAR(dictremover_doc, "deletes a key from a dictionary");

static PyType_Slot dictremover_slots[] = {

{Py_tp_dealloc, _DictRemover_dealloc},

{Py_tp_traverse, _DictRemover_traverse},

{Py_tp_clear, _DictRemover_clear},

{Py_tp_call, _DictRemover_call},

{Py_tp_doc, (void *)dictremover_doc},

{0, NULL},

};

static PyType_Spec dictremover_spec = {

.name = "_ctypes.DictRemover",

.basicsize = sizeof(DictRemoverObject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_IMMUTABLETYPE),

.slots = dictremover_slots,

};

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

{

PyObject *obj;

DictRemoverObject *remover;

PyObject *proxy;

int result;

ctypes_state *st = GLOBAL_STATE();

obj = _PyObject_CallNoArgs((PyObject *)st->DictRemover_Type);

if (obj == NULL)

return -1;

remover = (DictRemoverObject *)obj;

assert(remover->key == NULL);

assert(remover->dict == NULL);

remover->key = Py_NewRef(key);

remover->dict = Py_NewRef(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;

}

static int

_PyDict_GetItemProxy(PyObject *dict, PyObject *key, PyObject **presult)

{

PyObject *item = PyDict_GetItemWithError(dict, key);

if (item == NULL) {

if (PyErr_Occurred()) {

return -1;

}

*presult = NULL;

return 0;

}

if (!PyWeakref_CheckProxy(item)) {

*presult = Py_NewRef(item);

return 0;

}

PyObject *ref;

if (PyWeakref_GetRef(item, &ref) < 0) {

return -1;

}

// ref is NULL if the referenced object was destroyed

*presult = ref;

return 0;

}

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

PyErr_NoMemory();

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

PyErr_NoMemory();

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, "%zd,", shape[k]);

} else {

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

}

strcat(new_prefix, buf);

}

}

result = _ctypes_alloc_format_string(new_prefix, suffix);

PyMem_Free(new_prefix);

return result;

}

typedef struct {

PyObject_HEAD

void *ptr;

PyObject *keep; // If set, a reference to the original CDataObject.

} StructParamObject;

static int

StructParam_traverse(StructParamObject *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

return 0;

}

static int

StructParam_clear(StructParamObject *self)

{

Py_CLEAR(self->keep);

return 0;

}

static void

StructParam_dealloc(PyObject *myself)

{

StructParamObject *self = (StructParamObject *)myself;

PyTypeObject *tp = Py_TYPE(self);

PyObject_GC_UnTrack(myself);

(void)StructParam_clear(self);

PyMem_Free(self->ptr);

tp->tp_free(myself);

Py_DECREF(tp);

}

static PyType_Slot structparam_slots[] = {

{Py_tp_traverse, StructParam_traverse},

{Py_tp_clear, StructParam_clear},

{Py_tp_dealloc, StructParam_dealloc},

{0, NULL},

};

static PyType_Spec structparam_spec = {

.name = "_ctypes.StructParam_Type",

.basicsize = sizeof(StructParamObject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE |

Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_DISALLOW_INSTANTIATION),

.slots = structparam_slots,

};

static PyCArgObject *

StructUnionType_paramfunc(CDataObject *self)

{

PyCArgObject *parg;

PyObject *obj;

StgDictObject *stgdict;

void *ptr;

if ((size_t)self->b_size > sizeof(void*)) {

ptr = PyMem_Malloc(self->b_size);

if (ptr == NULL) {

return NULL;

}

memcpy(ptr, self->b_ptr, self->b_size);

/* Create a Python object which calls PyMem_Free(ptr) in

ctypes_state *st = GLOBAL_STATE();

PyTypeObject *tp = st->StructParam_Type;

obj = tp->tp_alloc(tp, 0);

if (obj == NULL) {

PyMem_Free(ptr);

return NULL;

}

StructParamObject *struct_param = (StructParamObject *)obj;

struct_param->ptr = ptr;

struct_param->keep = Py_NewRef(self);

} else {

ptr = self->b_ptr;

obj = Py_NewRef(self);

}

parg = PyCArgObject_new();

if (parg == NULL) {

Py_DECREF(obj);

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;

parg->value.p = ptr;

parg->size = self->b_size;

parg->obj = obj;

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

int r = PyDict_Contains(result->tp_dict, &_Py_ID(_abstract_));

if (r > 0)

return (PyObject *)result;

if (r < 0) {

Py_DECREF(result);

return NULL;

}

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

if (!dict) {

Py_DECREF(result);

return NULL;

}

if (!isStruct) {

dict->flags |= TYPEFLAG_HASUNION;

}

/* 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_GetItemWithError((PyObject *)dict, &_Py_ID(_fields_));

if (fields) {

if (PyObject_SetAttr((PyObject *)result, &_Py_ID(_fields_), fields) < 0) {

Py_DECREF(result);

return NULL;

}

return (PyObject *)result;

}

else if (PyErr_Occurred()) {

Py_DECREF(result);

return NULL;

}

else {

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;

}

}

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

}

PyDoc_STRVAR(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);

}

PyDoc_STRVAR(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;

}

if (PySys_Audit("ctypes.cdata/buffer", "nnn",

(Py_ssize_t)buffer->buf, buffer->len, offset) < 0) {

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;

}

PyDoc_STRVAR(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;

}

if (PySys_Audit("ctypes.cdata/buffer", "nnn",

(Py_ssize_t)buffer.buf, buffer.len, offset) < 0) {

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;

}

PyDoc_STRVAR(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;

if (PySys_Audit("ctypes.dlsym", "O", args) < 0) {

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

Py_BEGIN_ALLOW_THREADS

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

Py_END_ALLOW_THREADS

if (!address) {

PyErr_Format(PyExc_ValueError,

"symbol '%s' not found",

name);

return NULL;

}

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

if (!address) {

#ifdef __CYGWIN__

PyErr_Format(PyExc_ValueError,

"symbol '%s' not found",

name);

PyErr_SetString(PyExc_ValueError, dlerror());

return NULL;

}

return PyCData_AtAddress(type, address);

}

PyDoc_STRVAR(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) {

return Py_NewRef(value);

}

ctypes_state *st = GLOBAL_STATE();

if (PyCArg_CheckExact(st, value)) {

PyCArgObject *p = (PyCArgObject *)value;

PyObject *ob = p->obj;

const char *ob_name;

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

return Py_NewRef(value);

}

}

ob_name = (ob) ? Py_TYPE(ob)->tp_name : "???";

PyErr_Format(PyExc_TypeError,

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

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

return NULL;

}

if (PyObject_GetOptionalAttr(value, &_Py_ID(_as_parameter_), &as_parameter) < 0) {

return NULL;

}

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 %s",

((PyTypeObject *)type)->tp_name,

Py_TYPE(value)->tp_name);

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

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

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

PyDoc_STR("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_vectorcall_offset */