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

#include "pycore_unicodeobject.h" // _PyUnicode_EqualToASCIIString()

#include "pycore_pyatomic_ft_wrappers.h"

#include "pycore_object.h"

#include "pycore_tuple.h" // _PyTuple_FromPair

#ifdef MS_WIN32

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

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

#define clinic_state() (get_module_state_by_class(cls))

#define clinic_state_sub() (get_module_state_by_class(cls->tp_base))

#include "clinic/_ctypes.c.h"

#undef clinic_state

#undef clinic_state_sub

typedef struct {

PyObject_HEAD

PyObject *key;

PyObject *dict;

} DictRemoverObject;

#define _DictRemoverObject_CAST(op) ((DictRemoverObject *)(op))

static int

_DictRemover_traverse(PyObject *myself, visitproc visit, void *arg)

{

DictRemoverObject *self = _DictRemoverObject_CAST(myself);

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->key);

Py_VISIT(self->dict);

return 0;

}

static int

_DictRemover_clear(PyObject *myself)

{

DictRemoverObject *self = _DictRemoverObject_CAST(myself);

Py_CLEAR(self->key);

Py_CLEAR(self->dict);

return 0;

}

static void

_DictRemover_dealloc(PyObject *myself)

{

PyTypeObject *tp = Py_TYPE(myself);

PyObject_GC_UnTrack(myself);

(void)_DictRemover_clear(myself);

tp->tp_free(myself);

Py_DECREF(tp);

}

static PyObject *

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

{

DictRemoverObject *self = _DictRemoverObject_CAST(myself);

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

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

PyErr_FormatUnraisable("Exception ignored while "

"calling _ctypes.DictRemover");

}

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(ctypes_state *st, PyObject *dict, PyObject *key, PyObject *item)

{

PyObject *obj;

DictRemoverObject *remover;

PyObject *proxy;

int result;

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)

{

int rc = PyDict_GetItemRef(dict, key, presult);

PyObject *item = *presult;

if (item && PyWeakref_CheckProxy(item)) {

rc = PyWeakref_GetRef(item, presult);

Py_DECREF(item);

}

return rc;

}

static char *

_ctypes_alloc_format_string_for_type(const char *code, int big_endian)

{

const char *pep_code = NULL;

switch (code[0]) {

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

}

char *result = PyMem_Malloc(1 + strlen(pep_code) + 1);

if (result == NULL) {

PyErr_NoMemory();

return NULL;

}

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

strcpy(result + 1, pep_code);

return result;

}

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

}

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

#define _StructParamObject_CAST(op) ((StructParamObject *)(op))

static int

StructParam_traverse(PyObject *myself, visitproc visit, void *arg)

{

StructParamObject *self = _StructParamObject_CAST(myself);

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->keep);

return 0;

}

static int

StructParam_clear(PyObject *myself)

{

StructParamObject *self = _StructParamObject_CAST(myself);

Py_CLEAR(self->keep);

return 0;

}

static void

StructParam_dealloc(PyObject *myself)

{

StructParamObject *self = _StructParamObject_CAST(myself);

PyTypeObject *tp = Py_TYPE(self);

PyObject_GC_UnTrack(myself);

(void)StructParam_clear(myself);

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 int

CType_Type_traverse(PyObject *self, visitproc visit, void *arg)

{

StgInfo *info = _PyStgInfo_FromType_DuringGC(self);

if (info) {

Py_VISIT(info->proto);

Py_VISIT(info->argtypes);

Py_VISIT(info->converters);

Py_VISIT(info->restype);

Py_VISIT(info->checker);

Py_VISIT(info->pointer_type);

Py_VISIT(info->module);

}

Py_VISIT(Py_TYPE(self));

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

}

ctype_clear_stginfo(StgInfo *info)

{

assert(info);

Py_CLEAR(info->proto);

Py_CLEAR(info->argtypes);

Py_CLEAR(info->converters);

Py_CLEAR(info->restype);

Py_CLEAR(info->checker);

Py_CLEAR(info->pointer_type);

Py_CLEAR(info->module); // decref the module last

}

ctype_free_stginfo_members(StgInfo *info)

{

assert(info);

PyMem_Free(info->ffi_type_pointer.elements);

info->ffi_type_pointer.elements = NULL;

PyMem_Free(info->format);

info->format = NULL;

PyMem_Free(info->shape);

info->shape = NULL;

ctype_clear_stginfo(info);

}

static int

CType_Type_clear(PyObject *self)

{

StgInfo *info = _PyStgInfo_FromType_DuringGC(self);

if (info) {

ctype_clear_stginfo(info);

}

return PyType_Type.tp_clear(self);

}

static void

CType_Type_dealloc(PyObject *self)

{

StgInfo *info = _PyStgInfo_FromType_DuringGC(self);

if (info) {

ctype_free_stginfo_members(info);

}

PyTypeObject *tp = Py_TYPE(self);

PyType_Type.tp_dealloc(self);

Py_DECREF(tp);

}

static PyObject *

_ctypes_CType_Type___sizeof___impl(PyObject *self, PyTypeObject *cls)

{

Py_ssize_t size = Py_TYPE(self)->tp_basicsize;

size += Py_TYPE(self)->tp_itemsize * Py_SIZE(self);

ctypes_state *st = get_module_state_by_class(cls);

StgInfo *info;

if (PyStgInfo_FromType(st, self, &info) < 0) {

return NULL;

}

if (info) {

if (info->format) {

size += strlen(info->format) + 1;

}

if (info->ffi_type_pointer.elements) {

size += (info->length + 1) * sizeof(ffi_type *);

}

size += info->ndim * sizeof(Py_ssize_t);

}

return PyLong_FromSsize_t(size);

}

static PyObject *

_ctypes_CType_Type___pointer_type___get_impl(PyObject *self)

{

ctypes_state *st = get_module_state_by_def(Py_TYPE(self));

StgInfo *info;

if (PyStgInfo_FromType(st, self, &info) < 0) {

return NULL;

}

if (!info) {

PyErr_Format(PyExc_TypeError, "%R must have storage info", self);

return NULL;

}

PyObject *pointer_type;

STGINFO_LOCK(info);

pointer_type = Py_XNewRef(info->pointer_type);

STGINFO_UNLOCK();

if (pointer_type) {

return pointer_type;

}

PyErr_Format(PyExc_AttributeError,

"%R has no attribute '__pointer_type__'",

self);

return NULL;

}

static int

_ctypes_CType_Type___pointer_type___set_impl(PyObject *self, PyObject *value)

{

ctypes_state *st = get_module_state_by_def(Py_TYPE(self));

StgInfo *info;

if (PyStgInfo_FromType(st, self, &info) < 0) {

return -1;

}

if (!info) {

PyErr_Format(PyExc_TypeError, "%R must have storage info", self);

return -1;

}

STGINFO_LOCK(info);

Py_XSETREF(info->pointer_type, Py_XNewRef(value));

STGINFO_UNLOCK();

return 0;

}

static PyObject *

CType_Type_repeat(PyObject *self, Py_ssize_t length);

static PyMethodDef ctype_methods[] = {

_CTYPES_CTYPE_TYPE___SIZEOF___METHODDEF

{0},

};

static PyGetSetDef ctype_getsets[] = {

_CTYPES_CTYPE_TYPE___POINTER_TYPE___GETSETDEF

{ NULL, NULL }

};

static PyType_Slot ctype_type_slots[] = {

{Py_tp_token, Py_TP_USE_SPEC},

{Py_tp_traverse, CType_Type_traverse},

{Py_tp_clear, CType_Type_clear},

{Py_tp_dealloc, CType_Type_dealloc},

{Py_tp_methods, ctype_methods},

{Py_tp_getset, ctype_getsets},

// Sequence protocol.

{Py_sq_repeat, CType_Type_repeat},

{0, NULL},

};

PyType_Spec pyctype_type_spec = {

.name = "_ctypes.CType_Type",

.basicsize = -(Py_ssize_t)sizeof(StgInfo),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE |

Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_BASETYPE ),

.slots = ctype_type_slots,

};

static PyCArgObject *

StructUnionType_paramfunc(ctypes_state *st, CDataObject *self)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(self);

PyCArgObject *parg;

PyObject *obj;

void *ptr;

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

ptr = PyMem_Malloc(self->b_size);

if (ptr == NULL) {

PyErr_NoMemory();

return NULL;

}

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

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

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

if (parg == NULL) {

Py_DECREF(obj);

return NULL;

}

StgInfo *stginfo;

if (PyStgInfo_FromObject(st, (PyObject *)self, &stginfo) < 0) {

Py_DECREF(obj);

return NULL;

}

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

parg->tag = "V";

parg->pffi_type = &stginfo->ffi_type_pointer;

parg->value.p = ptr;

parg->size = self->b_size;

parg->obj = obj;

return parg;

}

static int

StructUnionType_init(PyObject *self, PyObject *args, PyObject *kwds, int isStruct)

{

PyObject *fields;

PyObject *attrdict = PyType_GetDict((PyTypeObject *)self);

if (!attrdict) {

return -1;

}

/* keep this for bw compatibility */

int r = PyDict_Contains(attrdict, &_Py_ID(_abstract_));

if (r > 0) {

Py_DECREF(attrdict);

return 0;

}

if (r < 0) {

Py_DECREF(attrdict);

return -1;

}

ctypes_state *st = get_module_state_by_def(Py_TYPE(self));

StgInfo *info = PyStgInfo_Init(st, (PyTypeObject *)self);

if (!info) {

Py_DECREF(attrdict);

return -1;

}

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

if (info->format == NULL) {

Py_DECREF(attrdict);

return -1;

}

info->paramfunc = StructUnionType_paramfunc;

if (PyDict_GetItemRef(attrdict, &_Py_ID(_fields_), &fields) < 0) {

Py_DECREF(attrdict);

return -1;

}

Py_CLEAR(attrdict);

if (fields) {

if (PyObject_SetAttr(self, &_Py_ID(_fields_), fields) < 0) {

Py_DECREF(fields);

return -1;

}

Py_DECREF(fields);

return 0;

}

else {

StgInfo *baseinfo;

if (PyStgInfo_FromType(st, (PyObject *)((PyTypeObject *)self)->tp_base,

&baseinfo) < 0) {

return -1;

}

if (baseinfo == NULL) {

return 0;

}

int ret = 0;

STGINFO_LOCK(baseinfo);

/* copy base info */

ret = PyCStgInfo_clone(info, baseinfo);

if (ret >= 0) {

stginfo_set_dict_final_lock_held(baseinfo); /* set the 'final' flag in the baseclass info */

}

STGINFO_UNLOCK();

return ret;

}

return 0;

}

static int

PyCStructType_init(PyObject *self, PyObject *args, PyObject *kwds)

{

return StructUnionType_init(self, args, kwds, 1);

}

static int

UnionType_init(PyObject *self, PyObject *args, PyObject *kwds)

{

return StructUnionType_init(self, args, kwds, 0);

}

static PyObject *

CDataType_from_address_impl(PyObject *type, PyTypeObject *cls,

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;

ctypes_state *st = get_module_state_by_class(cls);

return PyCData_AtAddress(st, type, buf);

}

static int

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

static PyObject *

CDataType_from_buffer_impl(PyObject *type, PyTypeObject *cls, PyObject *obj,

Py_ssize_t offset)

{

PyObject *mv;

PyObject *result;

Py_buffer *buffer;

ctypes_state *st = get_module_state_by_class(cls);

StgInfo *info;

if (PyStgInfo_FromType(st, type, &info) < 0) {

return NULL;

}

if (!info) {

PyErr_SetString(PyExc_TypeError, "abstract class");

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 (info->size > buffer->len - offset) {

PyErr_Format(PyExc_ValueError,

"Buffer size too small "

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

buffer->len, info->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(st, 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 inline PyObject *

generic_pycdata_new(ctypes_state *st,

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

static PyObject *

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

static PyObject *

CDataType_from_buffer_copy_impl(PyObject *type, PyTypeObject *cls,

Py_buffer *buffer, Py_ssize_t offset)

{

PyObject *result;

ctypes_state *st = get_module_state_by_class(cls);

StgInfo *info;

if (PyStgInfo_FromType(st, type, &info) < 0) {

return NULL;

}

if (!info) {

PyErr_SetString(PyExc_TypeError, "abstract class");

return NULL;

}

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

PyErr_Format(PyExc_ValueError,

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

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

return NULL;

}

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

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

return NULL;

}

result = generic_pycdata_new(st, (PyTypeObject *)type, NULL, NULL);

if (result != NULL) {

assert(_PyObject_IsUniquelyReferenced(result));

memcpy(((CDataObject *) result)->b_ptr, (char *)buffer->buf + offset, info->size);

}

return result;

}

static PyObject *

CDataType_in_dll_impl(PyObject *type, PyTypeObject *cls, PyObject *dll,

const char *name)