/*

ToDo:

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

StgInfo, and replace them by slot functions in StgInfo.

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

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

PyCStructType_Type __new__(), from_address(), __mul__(), from_param()

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

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

PyCArrayType_Type __new__(), from_address(), __mul__(), from_param()

PyCSimpleType_Type __new__(), from_address(), __mul__(), from_param()

PyCData_Type

Struct_Type __new__(), __init__()

PyCPointer_Type __new__(), __init__(), _as_parameter_, contents

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

Simple_Type __new__(), __init__(), _as_parameter_

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

*/

/*

* PyCStructType_Type

* UnionType_Type

* PyCPointerType_Type

* PyCArrayType_Type

* PyCSimpleType_Type

*

* PyCData_Type

* Struct_Type

* Union_Type

* PyCArray_Type

* Simple_Type

* PyCPointer_Type

* PyCField_Type

*

*/

#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#endif

#include "Python.h"

// windows.h must be included before pycore internal headers

#ifdef MS_WIN32

# include <windows.h>

#endif

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

#endif

#include <ffi.h>

#ifdef MS_WIN32

#include <malloc.h>

#ifndef IS_INTRESOURCE

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

#endif

#else

#include <dlfcn.h>

#endif

#include "ctypes.h"

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

/*[clinic input]

module _ctypes

class _ctypes.CFuncPtr "PyCFuncPtrObject *" "&PyCFuncPtr_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=58e8c99474bc631e]*/

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

};

int

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;

}

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

/*

Allocate a memory block for a pep3118 format string, filled with

a suitable PEP 3118 type code corresponding to the given ctypes

type. Returns NULL on failure, with the error indicator set.

This produces type codes in the standard size mode (cf. struct module),

since the endianness may need to be swapped to a non-native one

later on.

*/

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;

#else

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

#else

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

#else

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

}

/*

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.

*/

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;

}

/*

Allocate a memory block for a pep3118 format string, adding

the given prefix (if non-null), an additional shape prefix, and a suffix.

Returns NULL on failure, with the error indicator set. If called with

a suffix of NULL the error indicator must already be set.

*/

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;

}

/* StructParamObject and StructParam_Type are used in _ctypes_callproc()

for argument.keep to call PyMem_Free(ptr) on Py_DECREF(argument).

StructUnionType_paramfunc() creates such object when a ctypes Structure is

passed by copy to a C function. */

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,

};

/*

CType_Type - a base metaclass. Its instances (classes) have a StgInfo.

*/

/*[clinic input]

class _ctypes.CType_Type "PyObject *" "clinic_state()->CType_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=8389fc5b74a84f2a]*/

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

}

void

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

}

void

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

}

/*[clinic input]

_ctypes.CType_Type.__sizeof__

cls: defining_class

/

Return memory consumption of the type object.

[clinic start generated code]*/

static PyObject *

_ctypes_CType_Type___sizeof___impl(PyObject *self, PyTypeObject *cls)

/*[clinic end generated code: output=c68c235be84d03f3 input=d064433b6110d1ce]*/

{

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

}

/*[clinic input]

@getter

_ctypes.CType_Type.__pointer_type__

[clinic start generated code]*/

static PyObject *

_ctypes_CType_Type___pointer_type___get_impl(PyObject *self)

/*[clinic end generated code: output=718c9ff10b2b0012 input=ad12dc835943ceb8]*/

{

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;

}

/*[clinic input]

@setter

_ctypes.CType_Type.__pointer_type__

[clinic start generated code]*/

static int

_ctypes_CType_Type___pointer_type___set_impl(PyObject *self, PyObject *value)

/*[clinic end generated code: output=6259be8ea21693fa input=a05055fc7f4714b6]*/

{

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,

};

/*

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

__metaclass__ will call the constructor StructUnionType_new.

It initializes the C accessible fields somehow.

*/

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

return NULL;

}

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

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

its deallocator. The object will be destroyed

at _ctypes_callproc() cleanup. */

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

}

/*[clinic input]

class _ctypes.CDataType "PyObject *" "clinic_state()->CType_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=466a505a93d73156]*/

/*[clinic input]

_ctypes.CDataType.from_address as CDataType_from_address

type: self

cls: defining_class

value: object

/

C.from_address(integer) -> C instance

Access a C instance at the specified address.

[clinic start generated code]*/

static PyObject *

CDataType_from_address_impl(PyObject *type, PyTypeObject *cls,

PyObject *value)

/*[clinic end generated code: output=5be4a7c0d9aa6c74 input=827a22cefe380c01]*/

{

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

/*[clinic input]

_ctypes.CDataType.from_buffer as CDataType_from_buffer

type: self

cls: defining_class

obj: object

offset: Py_ssize_t(allow_negative=False) = 0

/

C.from_buffer(object, offset=0) -> C instance

Create a C instance from a writeable buffer.

[clinic start generated code]*/

static PyObject *

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

Py_ssize_t offset)

/*[clinic end generated code: output=57604e99635abd31 input=8f43e6bc44373180]*/

{

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

/*[clinic input]

_ctypes.CDataType.from_buffer_copy as CDataType_from_buffer_copy

type: self

cls: defining_class

buffer: Py_buffer

offset: Py_ssize_t(allow_negative=False) = 0

/

C.from_buffer_copy(object, offset=0) -> C instance

Create a C instance from a readable buffer.

[clinic start generated code]*/

static PyObject *

CDataType_from_buffer_copy_impl(PyObject *type, PyTypeObject *cls,

Py_buffer *buffer, Py_ssize_t offset)

/*[clinic end generated code: output=c8fc62b03e5cc6fa input=41f97f512295ceec]*/

{

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;

}

/*[clinic input]

_ctypes.CDataType.in_dll as CDataType_in_dll

type: self

cls: defining_class

dll: object

name: str

/

C.in_dll(dll, name) -> C instance

Access a C instance in a dll.

[clinic start generated code]*/

static PyObject *

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

const char *name)

/*[clinic end generated code: output=d0e5c43b66bfa21f input=f85bf281477042b4]*/