#$@%#$%!

Ngiler SH3LL 360
: / opt / alt / python39 / include / python3.9 / cpython /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : abstract.h \| Size : 13.87 KB
#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); / 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( PyThreadState tstate, 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( PyThreadState tstate, 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_ssize_t offset; vectorcallfunc ptr; assert(callable != NULL); tp = Py_TYPE(callable); if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { return NULL; } assert(PyCallable_Check(callable)); offset = tp->tp_vectorcall_offset; assert(offset > 0); memcpy(&ptr, (char ) callable + offset, sizeof(ptr)); 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 contain strings and all keys must be unique. Return the result on success. Raise an exception and return NULL on error. / static inline PyObject _PyObject_VectorcallTstate(PyThreadState tstate, PyObject callable, PyObject const args, size_t nargsf, PyObject kwnames) { vectorcallfunc func; PyObject res; 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(tstate, callable, args, nargs, kwnames); } res = func(callable, args, nargsf, kwnames); return _Py_CheckFunctionResult(tstate, callable, res, NULL); } static inline PyObject * PyObject_Vectorcall(PyObject callable, PyObject const args, size_t nargsf, PyObject kwnames) { PyThreadState tstate = PyThreadState_GET(); return _PyObject_VectorcallTstate(tstate, callable, args, nargsf, kwnames); } // Backwards compatibility aliases for API that was provisional in Python 3.8 #define _PyObject_Vectorcall PyObject_Vectorcall #define _PyObject_VectorcallMethod PyObject_VectorcallMethod #define _PyObject_FastCallDict PyObject_VectorcallDict #define _PyVectorcall_Function PyVectorcall_Function #define _PyObject_CallOneArg PyObject_CallOneArg #define _PyObject_CallMethodNoArgs PyObject_CallMethodNoArgs #define _PyObject_CallMethodOneArg PyObject_CallMethodOneArg / 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_VectorcallDict( 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); static inline PyObject _PyObject_FastCallTstate(PyThreadState tstate, PyObject func, PyObject const args, Py_ssize_t nargs) { return _PyObject_VectorcallTstate(tstate, func, args, (size_t)nargs, NULL); } /* Same as PyObject_Vectorcall except without keyword arguments / static inline PyObject _PyObject_FastCall(PyObject func, PyObject const args, Py_ssize_t nargs) { PyThreadState tstate = PyThreadState_GET(); return _PyObject_FastCallTstate(tstate, func, args, nargs); } /* Call a callable without any arguments Private static inline function variant of public function PyObject_CallNoArgs(). / static inline PyObject _PyObject_CallNoArg(PyObject func) { PyThreadState tstate = PyThreadState_GET(); return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL); } static inline PyObject * PyObject_CallOneArg(PyObject func, PyObject arg) { PyObject _args[2]; PyObject args; PyThreadState tstate; size_t nargsf; assert(arg != NULL); args = _args + 1; // For PY_VECTORCALL_ARGUMENTS_OFFSET args[0] = arg; tstate = PyThreadState_GET(); nargsf = 1 \| PY_VECTORCALL_ARGUMENTS_OFFSET; return _PyObject_VectorcallTstate(tstate, func, args, nargsf, NULL); } PyAPI_FUNC(PyObject ) PyObject_VectorcallMethod( PyObject name, PyObject const args, size_t nargsf, PyObject kwnames); static inline PyObject PyObject_CallMethodNoArgs(PyObject self, PyObject name) { return PyObject_VectorcallMethod(name, &self, 1 \| PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); } static inline PyObject * PyObject_CallMethodOneArg(PyObject self, PyObject name, PyObject arg) { PyObject args[2] = {self, arg}; assert(arg != NULL); return PyObject_VectorcallMethod(name, args, 2 \| PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); } /* 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, ...); static inline PyObject * _PyObject_VectorcallMethodId( _Py_Identifier name, PyObject const args, size_t nargsf, PyObject kwnames) { PyObject oname = _PyUnicode_FromId(name); / borrowed / if (!oname) { return NULL; } return PyObject_VectorcallMethod(oname, args, nargsf, kwnames); } static inline PyObject _PyObject_CallMethodIdNoArgs(PyObject self, _Py_Identifier name) { return _PyObject_VectorcallMethodId(name, &self, 1 \| PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); } static inline PyObject * _PyObject_CallMethodIdOneArg(PyObject self, _Py_Identifier name, PyObject arg) { PyObject args[2] = {self, arg}; assert(arg != NULL); return _PyObject_VectorcallMethodId(name, args, 2 \| PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); } 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. / PyAPI_FUNC(int) PyObject_CheckBuffer(PyObject obj); /* 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(Py_ssize_t) PyBuffer_SizeFromFormat(const char format); /* 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) \ (Py_TYPE(obj)->tp_iternext != NULL && \ Py_TYPE(obj)->tp_iternext != &_PyObject_NextNotImplemented) / === 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 Back

Edit File : abstract.h | Size : 13.87 KB

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

/* 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(
    PyThreadState *tstate,
    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(
    PyThreadState *tstate,
    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_ssize_t offset;
    vectorcallfunc ptr;

assert(callable != NULL);
    tp = Py_TYPE(callable);
    if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) {
        return NULL;
    }
    assert(PyCallable_Check(callable));
    offset = tp->tp_vectorcall_offset;
    assert(offset > 0);
    memcpy(&ptr, (char *) callable + offset, sizeof(ptr));
    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 contain strings and all keys must be unique.

Return the result on success. Raise an exception and return NULL on
   error. */
static inline PyObject *
_PyObject_VectorcallTstate(PyThreadState *tstate, PyObject *callable,
                           PyObject *const *args, size_t nargsf,
                           PyObject *kwnames)
{
    vectorcallfunc func;
    PyObject *res;

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(tstate, callable, args, nargs, kwnames);
    }
    res = func(callable, args, nargsf, kwnames);
    return _Py_CheckFunctionResult(tstate, callable, res, NULL);
}

static inline PyObject *
PyObject_Vectorcall(PyObject *callable, PyObject *const *args,
                     size_t nargsf, PyObject *kwnames)
{
    PyThreadState *tstate = PyThreadState_GET();
    return _PyObject_VectorcallTstate(tstate, callable,
                                      args, nargsf, kwnames);
}

// Backwards compatibility aliases for API that was provisional in Python 3.8
#define _PyObject_Vectorcall PyObject_Vectorcall
#define _PyObject_VectorcallMethod PyObject_VectorcallMethod
#define _PyObject_FastCallDict PyObject_VectorcallDict
#define _PyVectorcall_Function PyVectorcall_Function
#define _PyObject_CallOneArg PyObject_CallOneArg
#define _PyObject_CallMethodNoArgs PyObject_CallMethodNoArgs
#define _PyObject_CallMethodOneArg PyObject_CallMethodOneArg

/* 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_VectorcallDict(
    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);

static inline PyObject *
_PyObject_FastCallTstate(PyThreadState *tstate, PyObject *func, PyObject *const *args, Py_ssize_t nargs)
{
    return _PyObject_VectorcallTstate(tstate, func, args, (size_t)nargs, NULL);
}

/* Same as PyObject_Vectorcall except without keyword arguments */
static inline PyObject *
_PyObject_FastCall(PyObject *func, PyObject *const *args, Py_ssize_t nargs)
{
    PyThreadState *tstate = PyThreadState_GET();
    return _PyObject_FastCallTstate(tstate, func, args, nargs);
}

/* Call a callable without any arguments
   Private static inline function variant of public function
   PyObject_CallNoArgs(). */
static inline PyObject *
_PyObject_CallNoArg(PyObject *func) {
    PyThreadState *tstate = PyThreadState_GET();
    return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL);
}

static inline PyObject *
PyObject_CallOneArg(PyObject *func, PyObject *arg)
{
    PyObject *_args[2];
    PyObject **args;
    PyThreadState *tstate;
    size_t nargsf;

assert(arg != NULL);
    args = _args + 1;  // For PY_VECTORCALL_ARGUMENTS_OFFSET
    args[0] = arg;
    tstate = PyThreadState_GET();
    nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;
    return _PyObject_VectorcallTstate(tstate, func, args, nargsf, NULL);
}

PyAPI_FUNC(PyObject *) PyObject_VectorcallMethod(
    PyObject *name, PyObject *const *args,
    size_t nargsf, PyObject *kwnames);

static inline PyObject *
PyObject_CallMethodNoArgs(PyObject *self, PyObject *name)
{
    return PyObject_VectorcallMethod(name, &self,
           1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
}

static inline PyObject *
PyObject_CallMethodOneArg(PyObject *self, PyObject *name, PyObject *arg)
{
    PyObject *args[2] = {self, arg};

assert(arg != NULL);
    return PyObject_VectorcallMethod(name, args,
           2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
}

/* 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,
    ...);

static inline PyObject *
_PyObject_VectorcallMethodId(
    _Py_Identifier *name, PyObject *const *args,
    size_t nargsf, PyObject *kwnames)
{
    PyObject *oname = _PyUnicode_FromId(name); /* borrowed */
    if (!oname) {
        return NULL;
    }
    return PyObject_VectorcallMethod(oname, args, nargsf, kwnames);
}

static inline PyObject *
_PyObject_CallMethodIdNoArgs(PyObject *self, _Py_Identifier *name)
{
    return _PyObject_VectorcallMethodId(name, &self,
           1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
}

static inline PyObject *
_PyObject_CallMethodIdOneArg(PyObject *self, _Py_Identifier *name, PyObject *arg)
{
    PyObject *args[2] = {self, arg};

assert(arg != NULL);
    return _PyObject_VectorcallMethodId(name, args,
           2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
}

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. */
PyAPI_FUNC(int) PyObject_CheckBuffer(PyObject *obj);

/* 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(Py_ssize_t) PyBuffer_SizeFromFormat(const char *format);

/* 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) \
    (Py_TYPE(obj)->tp_iternext != NULL && \
     Py_TYPE(obj)->tp_iternext != &_PyObject_NextNotImplemented)

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

Back