| #ifndef Py_CPYTHON_ABSTRACTOBJECT_H |
| # error "this header file must not be included directly" |
| #endif |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /* === Object Protocol ================================================== */ |
| |
| #ifdef PY_SSIZE_T_CLEAN |
| # define _PyObject_CallMethodId _PyObject_CallMethodId_SizeT |
| #endif |
| |
| /* Convert keyword arguments from the FASTCALL (stack: C array, kwnames: tuple) |
| format to a Python dictionary ("kwargs" dict). |
| |
| The type of kwnames keys is not checked. The final function getting |
| arguments is responsible to check if all keys are strings, for example using |
| PyArg_ParseTupleAndKeywords() or PyArg_ValidateKeywordArguments(). |
| |
| Duplicate keys are merged using the last value. If duplicate keys must raise |
| an exception, the caller is responsible to implement an explicit keys on |
| kwnames. */ |
| PyAPI_FUNC(PyObject *) _PyStack_AsDict( |
| PyObject *const *values, |
| PyObject *kwnames); |
| |
| /* Convert (args, nargs, kwargs: dict) into a (stack, nargs, kwnames: tuple). |
| |
| Return 0 on success, raise an exception and return -1 on error. |
| |
| Write the new stack into *p_stack. If *p_stack is differen than args, it |
| must be released by PyMem_Free(). |
| |
| The stack uses borrowed references. |
| |
| The type of keyword keys is not checked, these checks should be done |
| later (ex: _PyArg_ParseStackAndKeywords). */ |
| PyAPI_FUNC(int) _PyStack_UnpackDict( |
| PyObject *const *args, |
| Py_ssize_t nargs, |
| PyObject *kwargs, |
| PyObject *const **p_stack, |
| PyObject **p_kwnames); |
| |
| /* Suggested size (number of positional arguments) for arrays of PyObject* |
| allocated on a C stack to avoid allocating memory on the heap memory. Such |
| array is used to pass positional arguments to call functions of the |
| _PyObject_Vectorcall() family. |
| |
| The size is chosen to not abuse the C stack and so limit the risk of stack |
| overflow. The size is also chosen to allow using the small stack for most |
| function calls of the Python standard library. On 64-bit CPU, it allocates |
| 40 bytes on the stack. */ |
| #define _PY_FASTCALL_SMALL_STACK 5 |
| |
| PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult(PyObject *callable, |
| PyObject *result, |
| const char *where); |
| |
| /* === Vectorcall protocol (PEP 590) ============================= */ |
| |
| /* Call callable using tp_call. Arguments are like _PyObject_Vectorcall() |
| or _PyObject_FastCallDict() (both forms are supported), |
| except that nargs is plainly the number of arguments without flags. */ |
| PyAPI_FUNC(PyObject *) _PyObject_MakeTpCall( |
| PyObject *callable, |
| PyObject *const *args, Py_ssize_t nargs, |
| PyObject *keywords); |
| |
| #define PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) |
| |
| static inline Py_ssize_t |
| PyVectorcall_NARGS(size_t n) |
| { |
| return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET; |
| } |
| |
| static inline vectorcallfunc |
| _PyVectorcall_Function(PyObject *callable) |
| { |
| PyTypeObject *tp = Py_TYPE(callable); |
| Py_ssize_t offset = tp->tp_vectorcall_offset; |
| vectorcallfunc *ptr; |
| if (!PyType_HasFeature(tp, _Py_TPFLAGS_HAVE_VECTORCALL)) { |
| return NULL; |
| } |
| assert(PyCallable_Check(callable)); |
| assert(offset > 0); |
| ptr = (vectorcallfunc*)(((char *)callable) + offset); |
| return *ptr; |
| } |
| |
| /* Call the callable object 'callable' with the "vectorcall" calling |
| convention. |
| |
| args is a C array for positional arguments. |
| |
| nargsf is the number of positional arguments plus optionally the flag |
| PY_VECTORCALL_ARGUMENTS_OFFSET which means that the caller is allowed to |
| modify args[-1]. |
| |
| kwnames is a tuple of keyword names. The values of the keyword arguments |
| are stored in "args" after the positional arguments (note that the number |
| of keyword arguments does not change nargsf). kwnames can also be NULL if |
| there are no keyword arguments. |
| |
| keywords must only contains str strings (no subclass), and all keys must |
| be unique. |
| |
| Return the result on success. Raise an exception and return NULL on |
| error. */ |
| static inline PyObject * |
| _PyObject_Vectorcall(PyObject *callable, PyObject *const *args, |
| size_t nargsf, PyObject *kwnames) |
| { |
| PyObject *res; |
| vectorcallfunc func; |
| assert(kwnames == NULL || PyTuple_Check(kwnames)); |
| assert(args != NULL || PyVectorcall_NARGS(nargsf) == 0); |
| func = _PyVectorcall_Function(callable); |
| if (func == NULL) { |
| Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); |
| return _PyObject_MakeTpCall(callable, args, nargs, kwnames); |
| } |
| res = func(callable, args, nargsf, kwnames); |
| return _Py_CheckFunctionResult(callable, res, NULL); |
| } |
| |
| /* Same as _PyObject_Vectorcall except that keyword arguments are passed as |
| dict, which may be NULL if there are no keyword arguments. */ |
| PyAPI_FUNC(PyObject *) _PyObject_FastCallDict( |
| PyObject *callable, |
| PyObject *const *args, |
| size_t nargsf, |
| PyObject *kwargs); |
| |
| /* Call "callable" (which must support vectorcall) with positional arguments |
| "tuple" and keyword arguments "dict". "dict" may also be NULL */ |
| PyAPI_FUNC(PyObject *) PyVectorcall_Call(PyObject *callable, PyObject *tuple, PyObject *dict); |
| |
| /* Same as _PyObject_Vectorcall except without keyword arguments */ |
| static inline PyObject * |
| _PyObject_FastCall(PyObject *func, PyObject *const *args, Py_ssize_t nargs) |
| { |
| return _PyObject_Vectorcall(func, args, (size_t)nargs, NULL); |
| } |
| |
| /* Call a callable without any arguments */ |
| static inline PyObject * |
| _PyObject_CallNoArg(PyObject *func) { |
| return _PyObject_Vectorcall(func, NULL, 0, NULL); |
| } |
| |
| PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend( |
| PyObject *callable, |
| PyObject *obj, |
| PyObject *args, |
| PyObject *kwargs); |
| |
| PyAPI_FUNC(PyObject *) _PyObject_FastCall_Prepend( |
| PyObject *callable, |
| PyObject *obj, |
| PyObject *const *args, |
| Py_ssize_t nargs); |
| |
| /* Like PyObject_CallMethod(), but expect a _Py_Identifier* |
| as the method name. */ |
| PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *obj, |
| _Py_Identifier *name, |
| const char *format, ...); |
| |
| PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *obj, |
| _Py_Identifier *name, |
| const char *format, |
| ...); |
| |
| PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs( |
| PyObject *obj, |
| struct _Py_Identifier *name, |
| ...); |
| |
| PyAPI_FUNC(int) _PyObject_HasLen(PyObject *o); |
| |
| /* Guess the size of object 'o' using len(o) or o.__length_hint__(). |
| If neither of those return a non-negative value, then return the default |
| value. If one of the calls fails, this function returns -1. */ |
| PyAPI_FUNC(Py_ssize_t) PyObject_LengthHint(PyObject *o, Py_ssize_t); |
| |
| /* === New Buffer API ============================================ */ |
| |
| /* Return 1 if the getbuffer function is available, otherwise return 0. */ |
| #define PyObject_CheckBuffer(obj) \ |
| (((obj)->ob_type->tp_as_buffer != NULL) && \ |
| ((obj)->ob_type->tp_as_buffer->bf_getbuffer != NULL)) |
| |
| /* This is a C-API version of the getbuffer function call. It checks |
| to make sure object has the required function pointer and issues the |
| call. |
| |
| Returns -1 and raises an error on failure and returns 0 on success. */ |
| PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view, |
| int flags); |
| |
| /* Get the memory area pointed to by the indices for the buffer given. |
| Note that view->ndim is the assumed size of indices. */ |
| PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices); |
| |
| /* Return the implied itemsize of the data-format area from a |
| struct-style description. */ |
| PyAPI_FUNC(int) PyBuffer_SizeFromFormat(const char *); |
| |
| /* Implementation in memoryobject.c */ |
| PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view, |
| Py_ssize_t len, char order); |
| |
| PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf, |
| Py_ssize_t len, char order); |
| |
| /* Copy len bytes of data from the contiguous chunk of memory |
| pointed to by buf into the buffer exported by obj. Return |
| 0 on success and return -1 and raise a PyBuffer_Error on |
| error (i.e. the object does not have a buffer interface or |
| it is not working). |
| |
| If fort is 'F', then if the object is multi-dimensional, |
| then the data will be copied into the array in |
| Fortran-style (first dimension varies the fastest). If |
| fort is 'C', then the data will be copied into the array |
| in C-style (last dimension varies the fastest). If fort |
| is 'A', then it does not matter and the copy will be made |
| in whatever way is more efficient. */ |
| PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src); |
| |
| /* Copy the data from the src buffer to the buffer of destination. */ |
| PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char fort); |
| |
| /*Fill the strides array with byte-strides of a contiguous |
| (Fortran-style if fort is 'F' or C-style otherwise) |
| array of the given shape with the given number of bytes |
| per element. */ |
| PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims, |
| Py_ssize_t *shape, |
| Py_ssize_t *strides, |
| int itemsize, |
| char fort); |
| |
| /* Fills in a buffer-info structure correctly for an exporter |
| that can only share a contiguous chunk of memory of |
| "unsigned bytes" of the given length. |
| |
| Returns 0 on success and -1 (with raising an error) on error. */ |
| PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf, |
| Py_ssize_t len, int readonly, |
| int flags); |
| |
| /* Releases a Py_buffer obtained from getbuffer ParseTuple's "s*". */ |
| PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view); |
| |
| /* ==== Iterators ================================================ */ |
| |
| #define PyIter_Check(obj) \ |
| ((obj)->ob_type->tp_iternext != NULL && \ |
| (obj)->ob_type->tp_iternext != &_PyObject_NextNotImplemented) |
| |
| /* === Number Protocol ================================================== */ |
| |
| #define PyIndex_Check(obj) \ |
| ((obj)->ob_type->tp_as_number != NULL && \ |
| (obj)->ob_type->tp_as_number->nb_index != NULL) |
| |
| /* === Sequence protocol ================================================ */ |
| |
| /* Assume tp_as_sequence and sq_item exist and that 'i' does not |
| need to be corrected for a negative index. */ |
| #define PySequence_ITEM(o, i)\ |
| ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) ) |
| |
| #define PY_ITERSEARCH_COUNT 1 |
| #define PY_ITERSEARCH_INDEX 2 |
| #define PY_ITERSEARCH_CONTAINS 3 |
| |
| /* Iterate over seq. |
| |
| Result depends on the operation: |
| |
| PY_ITERSEARCH_COUNT: return # of times obj appears in seq; -1 if |
| error. |
| PY_ITERSEARCH_INDEX: return 0-based index of first occurrence of |
| obj in seq; set ValueError and return -1 if none found; |
| also return -1 on error. |
| PY_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on |
| error. */ |
| PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq, |
| PyObject *obj, int operation); |
| |
| /* === Mapping protocol ================================================= */ |
| |
| PyAPI_FUNC(int) _PyObject_RealIsInstance(PyObject *inst, PyObject *cls); |
| |
| PyAPI_FUNC(int) _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls); |
| |
| PyAPI_FUNC(char *const *) _PySequence_BytesToCharpArray(PyObject* self); |
| |
| PyAPI_FUNC(void) _Py_FreeCharPArray(char *const array[]); |
| |
| /* For internal use by buffer API functions */ |
| PyAPI_FUNC(void) _Py_add_one_to_index_F(int nd, Py_ssize_t *index, |
| const Py_ssize_t *shape); |
| PyAPI_FUNC(void) _Py_add_one_to_index_C(int nd, Py_ssize_t *index, |
| const Py_ssize_t *shape); |
| |
| /* Convert Python int to Py_ssize_t. Do nothing if the argument is None. */ |
| PyAPI_FUNC(int) _Py_convert_optional_to_ssize_t(PyObject *, void *); |
| |
| #ifdef __cplusplus |
| } |
| #endif |