#if defined (__SVR4) && defined (__sun) # include <alloca.h> #endif #include "pycore_moduleobject.h" // _PyModule_GetState() #include "pycore_typeobject.h" // _PyType_GetModuleState() #if defined(Py_HAVE_C_COMPLEX) && defined(Py_FFI_SUPPORT_C_COMPLEX) # include "../_complex.h" // complex #endif #ifndef MS_WIN32 #define max(a, b) … #define min(a, b) … #define PARAMFLAG_FIN … #define PARAMFLAG_FOUT … #define PARAMFLAG_FLCID … #endif /* * bpo-13097: Max number of arguments CFuncPtr._argtypes_ and * _ctypes_callproc() will accept. * * This limit is enforced for the `alloca()` call in `_ctypes_callproc`, * to avoid allocating a massive buffer on the stack. */ #ifndef CTYPES_MAX_ARGCOUNT #ifdef __EMSCRIPTEN__ #define CTYPES_MAX_ARGCOUNT … #else #define CTYPES_MAX_ARGCOUNT … #endif #endif #if defined(__has_builtin) #if __has_builtin(__builtin_available) #define HAVE_BUILTIN_AVAILABLE … #endif #endif #ifdef MS_WIN32 #include <Unknwn.h> // for IUnknown interface #endif ctypes_state; extern struct PyModuleDef _ctypesmodule; static inline ctypes_state * get_module_state(PyObject *module) { … } static inline ctypes_state * get_module_state_by_class(PyTypeObject *cls) { … } static inline ctypes_state * get_module_state_by_def(PyTypeObject *cls) { … } extern PyType_Spec pyctype_type_spec; extern PyType_Spec carg_spec; extern PyType_Spec cfield_spec; extern PyType_Spec cthunk_spec; PyCArgObject; CDataObject; GETFUNC; SETFUNC; PARAMFUNC; /* A default buffer in CDataObject, which can be used for small C types. If this buffer is too small, PyMem_Malloc will be called to create a larger one, and this one is not used. Making CDataObject a variable size object would be a better solution, but more difficult in the presence of PyCFuncPtrObject. Maybe later. */ value; /* Hm. Are there CDataObject's which do not need the b_objects member? In this case we probably should introduce b_flags to mark it as present... If b_objects is not present/unused b_length is unneeded as well. */ struct tagCDataObject { … }; CThunkObject; #define CThunk_CheckExact(st, v) … PyCFuncPtrObject; extern int PyCStructUnionType_update_stginfo(PyObject *fields, PyObject *type, int isStruct); extern int PyType_stginfo(PyTypeObject *self, Py_ssize_t *psize, Py_ssize_t *palign, Py_ssize_t *plength); extern int PyObject_stginfo(PyObject *self, Py_ssize_t *psize, Py_ssize_t *palign, Py_ssize_t *plength); #define CDataObject_CheckExact(st, v) … #define CDataObject_Check(st, v) … #define _CDataObject_HasExternalBuffer(v) … #define PyCSimpleTypeObject_CheckExact(st, v) … #define PyCSimpleTypeObject_Check(st, v) … extern struct fielddesc *_ctypes_get_fielddesc(const char *fmt); extern PyObject *PyCData_AtAddress(ctypes_state *st, PyObject *type, void *buf); extern PyObject *PyCData_FromBytes(ctypes_state *st, PyObject *type, char *data, Py_ssize_t length); #define PyCArrayTypeObject_Check(st, v) … #define ArrayObject_Check(st, v) … #define PointerObject_Check(st, v) … #define PyCPointerTypeObject_Check(st, v) … #define PyCFuncPtrObject_Check(st,v) … #define PyCFuncPtrTypeObject_Check(st, v) … #define PyCStructTypeObject_Check(st, v) … extern PyObject * PyCArrayType_from_ctype(ctypes_state *st, PyObject *itemtype, Py_ssize_t length); extern PyMethodDef _ctypes_module_methods[]; extern CThunkObject *_ctypes_alloc_callback(ctypes_state *st, PyObject *callable, PyObject *converters, PyObject *restype, int flags); /* a table entry describing a predefined ctypes type */ struct fielddesc { … }; CFieldObject; /**************************************************************** StgInfo Since Python 3.13, ctypes-specific type information is stored in the corresponding type object, in a `StgInfo` struct accessed by the helpers below. Before that, each type's `tp_dict` was set to a dict *subclass* that included the fields that are now in StgInfo. The mechanism was called "StgDict"; a few references to that name might remain. Functions for accessing StgInfo are `static inline` for performance; see later in this file. **************************************************************** StgInfo fields setfunc and getfunc is only set for simple data types, it is copied from the corresponding fielddesc entry. These are functions to set and get the value in a memory block. They should probably by used by other types as well. proto is only used for Pointer and Array types - it points to the item type object. Probably all the magic ctypes methods (like from_param) should have C callable wrappers in the StgInfo. For simple data type, for example, the fielddesc table could have entries for C codec from_param functions or other methods as well, if a subtype overrides this method in Python at construction time, or assigns to it later, tp_setattro should update the StgInfo function to a generic one. Currently, PyCFuncPtr types have 'converters' and 'checker' entries in their type dict. They are only used to cache attributes from other entries, which is wrong. One use case is the .value attribute that all simple types have. But some complex structures, like VARIANT, represent a single value also, and should have this attribute. Another use case is a _check_retval_ function, which is called when a ctypes type is used as return type of a function to validate and compute the return value. Common ctypes protocol: - setfunc: store a python value in a memory block - getfunc: convert data from a memory block into a python value - checkfunc: validate and convert a return value from a function call - toparamfunc: convert a python value into a function argument *****************************************************************/ StgInfo; extern int PyCStgInfo_clone(StgInfo *dst_info, StgInfo *src_info); extern void ctype_clear_stginfo(StgInfo *info); PPROC; PyObject *_ctypes_callproc(ctypes_state *st, PPROC pProc, PyObject *arguments, #ifdef MS_WIN32 IUnknown *pIUnk, GUID *iid, #endif int flags, PyObject *argtypes, PyObject *restype, PyObject *checker); #define FUNCFLAG_STDCALL … #define FUNCFLAG_CDECL … #define FUNCFLAG_HRESULT … #define FUNCFLAG_PYTHONAPI … #define FUNCFLAG_USE_ERRNO … #define FUNCFLAG_USE_LASTERROR … #define TYPEFLAG_ISPOINTER … #define TYPEFLAG_HASPOINTER … #define DICTFLAG_FINAL … struct tagPyCArgObject { … }; #define PyCArg_CheckExact(st, v) … extern PyCArgObject *PyCArgObject_new(ctypes_state *st); extern PyObject * PyCData_get(ctypes_state *st, PyObject *type, GETFUNC getfunc, PyObject *src, Py_ssize_t index, Py_ssize_t size, char *ptr); extern int PyCData_set(ctypes_state *st, PyObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value, Py_ssize_t index, Py_ssize_t size, char *ptr); extern void _ctypes_extend_error(PyObject *exc_class, const char *fmt, ...); struct basespec { … }; extern ffi_type *_ctypes_get_ffi_type(ctypes_state *st, PyObject *obj); extern void _ctypes_free_closure(void *); extern void *_ctypes_alloc_closure(void); extern PyObject *PyCData_FromBaseObj(ctypes_state *st, PyObject *type, PyObject *base, Py_ssize_t index, char *adr); extern int _ctypes_simple_instance(ctypes_state *st, PyObject *obj); PyObject *_ctypes_get_errobj(ctypes_state *st, int **pspace); #ifdef USING_MALLOC_CLOSURE_DOT_C void Py_ffi_closure_free(void *p); void *Py_ffi_closure_alloc(size_t size, void** codeloc); #else #define Py_ffi_closure_free … #define Py_ffi_closure_alloc … #endif /**************************************************************** * Accessing StgInfo -- these are inlined for performance reasons. */ // `PyStgInfo_From**` functions get a PyCTypeDataObject. // These return -1 on error, 0 if "not found", 1 on OK. // (Currently, these do not return -1 in practice. This might change // in the future.) // // Common helper: static inline int _stginfo_from_type(ctypes_state *state, PyTypeObject *type, StgInfo **result) { … } // from a type: static inline int PyStgInfo_FromType(ctypes_state *state, PyObject *type, StgInfo **result) { … } // from an instance: static inline int PyStgInfo_FromObject(ctypes_state *state, PyObject *obj, StgInfo **result) { … } // from either a type or an instance: static inline int PyStgInfo_FromAny(ctypes_state *state, PyObject *obj, StgInfo **result) { … } /* A variant of PyStgInfo_FromType that doesn't need the state, * so it can be called from finalization functions when the module * state is torn down. */ static inline StgInfo * _PyStgInfo_FromType_NoState(PyObject *type) { … } // Initialize StgInfo on a newly created type static inline StgInfo * PyStgInfo_Init(ctypes_state *state, PyTypeObject *type) { … }
Codebase Browser
cpython