/pypy/module/cpyext/stubs.py
Python | 2430 lines | 2421 code | 5 blank | 4 comment | 1 complexity | 33da3fdae404e6c46f67ac6e98cb49dd MD5 | raw file
Large files files are truncated, but you can click here to view the full file
- from pypy.module.cpyext.api import (
- cpython_api, PyObject, PyObjectP, CANNOT_FAIL
- )
- from pypy.module.cpyext.complexobject import Py_complex_ptr as Py_complex
- from pypy.rpython.lltypesystem import rffi, lltype
- # we don't really care
- PyTypeObjectPtr = rffi.VOIDP
- Py_ssize_t = rffi.SSIZE_T
- PyMethodDef = rffi.VOIDP
- PyGetSetDef = rffi.VOIDP
- PyMemberDef = rffi.VOIDP
- Py_buffer = rffi.VOIDP
- va_list = rffi.VOIDP
- PyDateTime_Date = rffi.VOIDP
- PyDateTime_DateTime = rffi.VOIDP
- PyDateTime_Time = rffi.VOIDP
- wrapperbase = rffi.VOIDP
- FILE = rffi.VOIDP
- PyFileObject = rffi.VOIDP
- PyCodeObject = rffi.VOIDP
- PyFrameObject = rffi.VOIDP
- PyFloatObject = rffi.VOIDP
- _inittab = rffi.VOIDP
- PyThreadState = rffi.VOIDP
- PyInterpreterState = rffi.VOIDP
- Py_UNICODE = lltype.UniChar
- PyCompilerFlags = rffi.VOIDP
- _node = rffi.VOIDP
- Py_tracefunc = rffi.VOIDP
- @cpython_api([PyObject], lltype.Void)
- def _PyObject_Del(space, op):
- raise NotImplementedError
- @cpython_api([rffi.CCHARP], Py_ssize_t, error=CANNOT_FAIL)
- def PyBuffer_SizeFromFormat(space, format):
- """Return the implied ~Py_buffer.itemsize from the struct-stype
- ~Py_buffer.format."""
- raise NotImplementedError
- @cpython_api([rffi.INT_real, Py_ssize_t, Py_ssize_t, Py_ssize_t, lltype.Char], lltype.Void)
- def PyBuffer_FillContiguousStrides(space, ndim, shape, strides, itemsize, fortran):
- """Fill the strides array with byte-strides of a contiguous (C-style if
- fortran is 'C' or Fortran-style if fortran is 'F' array of the
- given shape with the given number of bytes per element."""
- raise NotImplementedError
- @cpython_api([Py_buffer], PyObject)
- def PyMemoryView_FromBuffer(space, view):
- """Create a memoryview object wrapping the given buffer-info structure view.
- The memoryview object then owns the buffer, which means you shouldn't
- try to release it yourself: it will be released on deallocation of the
- memoryview object."""
- raise NotImplementedError
- @cpython_api([PyObject, rffi.INT_real, lltype.Char], PyObject)
- def PyMemoryView_GetContiguous(space, obj, buffertype, order):
- """Create a memoryview object to a contiguous chunk of memory (in either
- 'C' or 'F'ortran order) from an object that defines the buffer
- interface. If memory is contiguous, the memoryview object points to the
- original memory. Otherwise copy is made and the memoryview points to a
- new bytes object."""
- raise NotImplementedError
- @cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
- def PyMemoryView_Check(space, obj):
- """Return true if the object obj is a memoryview object. It is not
- currently allowed to create subclasses of memoryview."""
- raise NotImplementedError
- @cpython_api([PyObject], Py_buffer)
- def PyMemoryView_GET_BUFFER(space, obj):
- """Return a pointer to the buffer-info structure wrapped by the given
- object. The object must be a memoryview instance; this macro doesn't
- check its type, you must do it yourself or you will risk crashes."""
- raise NotImplementedError
- @cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
- def PyByteArray_Check(space, o):
- """Return true if the object o is a bytearray object or an instance of a
- subtype of the bytearray type."""
- raise NotImplementedError
- @cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
- def PyByteArray_CheckExact(space, o):
- """Return true if the object o is a bytearray object, but not an instance of a
- subtype of the bytearray type."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyByteArray_FromObject(space, o):
- """Return a new bytearray object from any object, o, that implements the
- buffer protocol.
- XXX expand about the buffer protocol, at least somewhere"""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, Py_ssize_t], PyObject)
- def PyByteArray_FromStringAndSize(space, string, len):
- """Create a new bytearray object from string and its length, len. On
- failure, NULL is returned."""
- raise NotImplementedError
- @cpython_api([PyObject, PyObject], PyObject)
- def PyByteArray_Concat(space, a, b):
- """Concat bytearrays a and b and return a new bytearray with the result."""
- raise NotImplementedError
- @cpython_api([PyObject], Py_ssize_t, error=-1)
- def PyByteArray_Size(space, bytearray):
- """Return the size of bytearray after checking for a NULL pointer."""
- raise NotImplementedError
- @cpython_api([PyObject], rffi.CCHARP)
- def PyByteArray_AsString(space, bytearray):
- """Return the contents of bytearray as a char array after checking for a
- NULL pointer."""
- raise NotImplementedError
- @cpython_api([PyObject, Py_ssize_t], rffi.INT_real, error=-1)
- def PyByteArray_Resize(space, bytearray, len):
- """Resize the internal buffer of bytearray to len."""
- raise NotImplementedError
- @cpython_api([PyObject], rffi.CCHARP)
- def PyByteArray_AS_STRING(space, bytearray):
- """Macro version of PyByteArray_AsString()."""
- raise NotImplementedError
- @cpython_api([PyObject], Py_ssize_t, error=-1)
- def PyByteArray_GET_SIZE(space, bytearray):
- """Macro version of PyByteArray_Size()."""
- raise NotImplementedError
- @cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
- def PyCell_Check(space, ob):
- """Return true if ob is a cell object; ob must not be NULL."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyCell_New(space, ob):
- """Create and return a new cell object containing the value ob. The parameter may
- be NULL."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyCell_Get(space, cell):
- """Return the contents of the cell cell."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyCell_GET(space, cell):
- """Return the contents of the cell cell, but without checking that cell is
- non-NULL and a cell object."""
- borrow_from()
- raise NotImplementedError
- @cpython_api([PyObject, PyObject], rffi.INT_real, error=-1)
- def PyCell_Set(space, cell, value):
- """Set the contents of the cell object cell to value. This releases the
- reference to any current content of the cell. value may be NULL. cell
- must be non-NULL; if it is not a cell object, -1 will be returned. On
- success, 0 will be returned."""
- raise NotImplementedError
- @cpython_api([PyObject, PyObject], lltype.Void)
- def PyCell_SET(space, cell, value):
- """Sets the value of the cell object cell to value. No reference counts are
- adjusted, and no checks are made for safety; cell must be non-NULL and must
- be a cell object."""
- raise NotImplementedError
- @cpython_api([PyObject, PyObject], rffi.INT_real, error=CANNOT_FAIL)
- def PyClass_IsSubclass(space, klass, base):
- """Return true if klass is a subclass of base. Return false in all other cases."""
- raise NotImplementedError
- @cpython_api([PyObject, PyObject, PyObject], PyObject)
- def PyInstance_New(space, cls, arg, kw):
- """Create a new instance of a specific class. The parameters arg and kw are
- used as the positional and keyword parameters to the object's constructor."""
- raise NotImplementedError
- @cpython_api([PyObject], rffi.INT_real, error=-1)
- def PyCodec_Register(space, search_function):
- """Register a new codec search function.
- As side effect, this tries to load the encodings package, if not yet
- done, to make sure that it is always first in the list of search functions."""
- raise NotImplementedError
- @cpython_api([PyObject, rffi.CCHARP, rffi.CCHARP], PyObject)
- def PyCodec_Encode(space, object, encoding, errors):
- """Generic codec based encoding API.
- object is passed through the encoder function found for the given
- encoding using the error handling method defined by errors. errors may
- be NULL to use the default method defined for the codec. Raises a
- LookupError if no encoder can be found."""
- raise NotImplementedError
- @cpython_api([PyObject, rffi.CCHARP, rffi.CCHARP], PyObject)
- def PyCodec_Decode(space, object, encoding, errors):
- """Generic codec based decoding API.
- object is passed through the decoder function found for the given
- encoding using the error handling method defined by errors. errors may
- be NULL to use the default method defined for the codec. Raises a
- LookupError if no encoder can be found."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP], PyObject)
- def PyCodec_Encoder(space, encoding):
- """Get an encoder function for the given encoding."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP], PyObject)
- def PyCodec_Decoder(space, encoding):
- """Get a decoder function for the given encoding."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, PyObject, rffi.CCHARP], PyObject)
- def PyCodec_StreamReader(space, encoding, stream, errors):
- """Get a StreamReader factory function for the given encoding."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, PyObject, rffi.CCHARP], PyObject)
- def PyCodec_StreamWriter(space, encoding, stream, errors):
- """Get a StreamWriter factory function for the given encoding."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, PyObject], rffi.INT_real, error=-1)
- def PyCodec_RegisterError(space, name, error):
- """Register the error handling callback function error under the given name.
- This callback function will be called by a codec when it encounters
- unencodable characters/undecodable bytes and name is specified as the error
- parameter in the call to the encode/decode function.
- The callback gets a single argument, an instance of
- UnicodeEncodeError, UnicodeDecodeError or
- UnicodeTranslateError that holds information about the problematic
- sequence of characters or bytes and their offset in the original string (see
- unicodeexceptions for functions to extract this information). The
- callback must either raise the given exception, or return a two-item tuple
- containing the replacement for the problematic sequence, and an integer
- giving the offset in the original string at which encoding/decoding should be
- resumed.
- Return 0 on success, -1 on error."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP], PyObject)
- def PyCodec_LookupError(space, name):
- """Lookup the error handling callback function registered under name. As a
- special case NULL can be passed, in which case the error handling callback
- for "strict" will be returned."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyCodec_StrictErrors(space, exc):
- """Raise exc as an exception."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyCodec_IgnoreErrors(space, exc):
- """Ignore the unicode error, skipping the faulty input."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyCodec_ReplaceErrors(space, exc):
- """Replace the unicode encode error with ? or U+FFFD."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyCodec_XMLCharRefReplaceErrors(space, exc):
- """Replace the unicode encode error with XML character references."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyCodec_BackslashReplaceErrors(space, exc):
- r"""Replace the unicode encode error with backslash escapes (\x, \u and
- \U)."""
- raise NotImplementedError
- @cpython_api([Py_complex, Py_complex], Py_complex)
- def _Py_c_sum(space, left, right):
- """Return the sum of two complex numbers, using the C Py_complex
- representation."""
- raise NotImplementedError
- @cpython_api([Py_complex, Py_complex], Py_complex)
- def _Py_c_diff(space, left, right):
- """Return the difference between two complex numbers, using the C
- Py_complex representation."""
- raise NotImplementedError
- @cpython_api([Py_complex], Py_complex)
- def _Py_c_neg(space, complex):
- """Return the negation of the complex number complex, using the C
- Py_complex representation."""
- raise NotImplementedError
- @cpython_api([Py_complex, Py_complex], Py_complex)
- def _Py_c_prod(space, left, right):
- """Return the product of two complex numbers, using the C Py_complex
- representation."""
- raise NotImplementedError
- @cpython_api([Py_complex, Py_complex], Py_complex)
- def _Py_c_quot(space, dividend, divisor):
- """Return the quotient of two complex numbers, using the C Py_complex
- representation."""
- raise NotImplementedError
- @cpython_api([Py_complex, Py_complex], Py_complex)
- def _Py_c_pow(space, num, exp):
- """Return the exponentiation of num by exp, using the C Py_complex
- representation."""
- raise NotImplementedError
- @cpython_api([Py_complex], PyObject)
- def PyComplex_FromCComplex(space, v):
- """Create a new Python complex number object from a C Py_complex value."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, rffi.CCHARPP], rffi.DOUBLE, error=CANNOT_FAIL)
- def PyOS_ascii_strtod(space, nptr, endptr):
- """Convert a string to a double. This function behaves like the Standard C
- function strtod() does in the C locale. It does this without changing the
- current locale, since that would not be thread-safe.
- PyOS_ascii_strtod() should typically be used for reading configuration
- files or other non-user input that should be locale independent.
- See the Unix man page strtod(2) for details.
- Use PyOS_string_to_double() instead."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, rffi.SIZE_T, rffi.CCHARP, rffi.DOUBLE], rffi.CCHARP)
- def PyOS_ascii_formatd(space, buffer, buf_len, format, d):
- """Convert a double to a string using the '.' as the decimal
- separator. format is a printf()-style format string specifying the
- number format. Allowed conversion characters are 'e', 'E', 'f',
- 'F', 'g' and 'G'.
- The return value is a pointer to buffer with the converted string or NULL if
- the conversion failed.
- This function is removed in Python 2.7 and 3.1. Use PyOS_double_to_string()
- instead."""
- raise NotImplementedError
- @cpython_api([rffi.DOUBLE, lltype.Char, rffi.INT_real, rffi.INT_real, rffi.INTP], rffi.CCHARP)
- def PyOS_double_to_string(space, val, format_code, precision, flags, ptype):
- """Convert a double val to a string using supplied
- format_code, precision, and flags.
- format_code must be one of 'e', 'E', 'f', 'F',
- 'g', 'G' or 'r'. For 'r', the supplied precision
- must be 0 and is ignored. The 'r' format code specifies the
- standard repr() format.
- flags can be zero or more of the values Py_DTSF_SIGN,
- Py_DTSF_ADD_DOT_0, or Py_DTSF_ALT, or-ed together:
- Py_DTSF_SIGN means to always precede the returned string with a sign
- character, even if val is non-negative.
- Py_DTSF_ADD_DOT_0 means to ensure that the returned string will not look
- like an integer.
- Py_DTSF_ALT means to apply "alternate" formatting rules. See the
- documentation for the PyOS_snprintf() '#' specifier for
- details.
- If ptype is non-NULL, then the value it points to will be set to one of
- Py_DTST_FINITE, Py_DTST_INFINITE, or Py_DTST_NAN, signifying that
- val is a finite number, an infinite number, or not a number, respectively.
- The return value is a pointer to buffer with the converted string or
- NULL if the conversion failed. The caller is responsible for freeing the
- returned string by calling PyMem_Free().
- """
- raise NotImplementedError
- @cpython_api([rffi.CCHARP], rffi.DOUBLE, error=CANNOT_FAIL)
- def PyOS_ascii_atof(space, nptr):
- """Convert a string to a double in a locale-independent way.
- See the Unix man page atof(2) for details.
- Use PyOS_string_to_double() instead."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, rffi.CCHARP], rffi.CCHARP)
- def PyOS_stricmp(space, s1, s2):
- """Case insensitive comparison of strings. The function works almost
- identically to strcmp() except that it ignores the case.
- """
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, rffi.CCHARP, Py_ssize_t], rffi.CCHARP)
- def PyOS_strnicmp(space, s1, s2, size):
- """Case insensitive comparison of strings. The function works almost
- identically to strncmp() except that it ignores the case.
- """
- raise NotImplementedError
- @cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
- def PyTZInfo_Check(space, ob):
- """Return true if ob is of type PyDateTime_TZInfoType or a subtype of
- PyDateTime_TZInfoType. ob must not be NULL.
- """
- raise NotImplementedError
- @cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
- def PyTZInfo_CheckExact(space, ob):
- """Return true if ob is of type PyDateTime_TZInfoType. ob must not be
- NULL.
- """
- raise NotImplementedError
- @cpython_api([PyTypeObjectPtr, PyGetSetDef], PyObject)
- def PyDescr_NewGetSet(space, type, getset):
- raise NotImplementedError
- @cpython_api([PyTypeObjectPtr, PyMemberDef], PyObject)
- def PyDescr_NewMember(space, type, meth):
- raise NotImplementedError
- @cpython_api([PyTypeObjectPtr, wrapperbase, rffi.VOIDP], PyObject)
- def PyDescr_NewWrapper(space, type, wrapper, wrapped):
- raise NotImplementedError
- @cpython_api([PyTypeObjectPtr, PyMethodDef], PyObject)
- def PyDescr_NewClassMethod(space, type, method):
- raise NotImplementedError
- @cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
- def PyDescr_IsData(space, descr):
- """Return true if the descriptor objects descr describes a data attribute, or
- false if it describes a method. descr must be a descriptor object; there is
- no error checking.
- """
- raise NotImplementedError
- @cpython_api([PyObject, PyObject], PyObject)
- def PyWrapper_New(space, w_d, w_self):
- raise NotImplementedError
- @cpython_api([PyObject, PyObject, rffi.INT_real], rffi.INT_real, error=-1)
- def PyDict_Merge(space, a, b, override):
- """Iterate over mapping object b adding key-value pairs to dictionary a.
- b may be a dictionary, or any object supporting PyMapping_Keys()
- and PyObject_GetItem(). If override is true, existing pairs in a
- will be replaced if a matching key is found in b, otherwise pairs will
- only be added if there is not a matching key in a. Return 0 on
- success or -1 if an exception was raised.
- """
- raise NotImplementedError
- @cpython_api([PyObject, PyObject, rffi.INT_real], rffi.INT_real, error=-1)
- def PyDict_MergeFromSeq2(space, a, seq2, override):
- """Update or merge into dictionary a, from the key-value pairs in seq2.
- seq2 must be an iterable object producing iterable objects of length 2,
- viewed as key-value pairs. In case of duplicate keys, the last wins if
- override is true, else the first wins. Return 0 on success or -1
- if an exception was raised. Equivalent Python (except for the return
- value):
- def PyDict_MergeFromSeq2(a, seq2, override):
- for key, value in seq2:
- if override or key not in a:
- a[key] = value
- """
- raise NotImplementedError
- @cpython_api([rffi.INT_real], PyObject)
- def PyErr_SetFromWindowsErr(space, ierr):
- """This is a convenience function to raise WindowsError. If called with
- ierr of 0, the error code returned by a call to GetLastError()
- is used instead. It calls the Win32 function FormatMessage() to retrieve
- the Windows description of error code given by ierr or GetLastError(),
- then it constructs a tuple object whose first item is the ierr value and whose
- second item is the corresponding error message (gotten from
- FormatMessage()), and then calls PyErr_SetObject(PyExc_WindowsError,
- object). This function always returns NULL. Availability: Windows.
- Return value: always NULL."""
- raise NotImplementedError
- @cpython_api([PyObject, rffi.INT_real], PyObject)
- def PyErr_SetExcFromWindowsErr(space, type, ierr):
- """Similar to PyErr_SetFromWindowsErr(), with an additional parameter
- specifying the exception type to be raised. Availability: Windows.
- Return value: always NULL."""
- raise NotImplementedError
- @cpython_api([rffi.INT_real, rffi.CCHARP], PyObject)
- def PyErr_SetFromWindowsErrWithFilename(space, ierr, filename):
- """Similar to PyErr_SetFromWindowsErr(), with the additional behavior that
- if filename is not NULL, it is passed to the constructor of
- WindowsError as a third parameter. Availability: Windows.
- Return value: always NULL."""
- raise NotImplementedError
- @cpython_api([PyObject, rffi.INT_real, rffi.CCHARP], PyObject)
- def PyErr_SetExcFromWindowsErrWithFilename(space, type, ierr, filename):
- """Similar to PyErr_SetFromWindowsErrWithFilename(), with an additional
- parameter specifying the exception type to be raised. Availability: Windows.
- Return value: always NULL."""
- raise NotImplementedError
- @cpython_api([PyObject, rffi.CCHARP, rffi.CCHARP, rffi.INT_real, rffi.CCHARP, PyObject], rffi.INT_real, error=-1)
- def PyErr_WarnExplicit(space, category, message, filename, lineno, module, registry):
- """Issue a warning message with explicit control over all warning attributes. This
- is a straightforward wrapper around the Python function
- warnings.warn_explicit(), see there for more information. The module
- and registry arguments may be set to NULL to get the default effect
- described there."""
- raise NotImplementedError
- @cpython_api([rffi.INT_real], rffi.INT_real, error=CANNOT_FAIL)
- def PySignal_SetWakeupFd(space, fd):
- """This utility function specifies a file descriptor to which a '\0' byte will
- be written whenever a signal is received. It returns the previous such file
- descriptor. The value -1 disables the feature; this is the initial state.
- This is equivalent to signal.set_wakeup_fd() in Python, but without any
- error checking. fd should be a valid file descriptor. The function should
- only be called from the main thread."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, rffi.CCHARP, Py_ssize_t, Py_ssize_t, Py_ssize_t, rffi.CCHARP], PyObject)
- def PyUnicodeDecodeError_Create(space, encoding, object, length, start, end, reason):
- """Create a UnicodeDecodeError object with the attributes encoding,
- object, length, start, end and reason."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, rffi.CWCHARP, Py_ssize_t, Py_ssize_t, Py_ssize_t, rffi.CCHARP], PyObject)
- def PyUnicodeEncodeError_Create(space, encoding, object, length, start, end, reason):
- """Create a UnicodeEncodeError object with the attributes encoding,
- object, length, start, end and reason."""
- raise NotImplementedError
- @cpython_api([rffi.CWCHARP, Py_ssize_t, Py_ssize_t, Py_ssize_t, rffi.CCHARP], PyObject)
- def PyUnicodeTranslateError_Create(space, object, length, start, end, reason):
- """Create a UnicodeTranslateError object with the attributes object,
- length, start, end and reason."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyUnicodeDecodeError_GetEncoding(space, exc):
- """Return the encoding attribute of the given exception object."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyUnicodeDecodeError_GetObject(space, exc):
- """Return the object attribute of the given exception object."""
- raise NotImplementedError
- @cpython_api([PyObject, Py_ssize_t], rffi.INT_real, error=-1)
- def PyUnicodeDecodeError_GetStart(space, exc, start):
- """Get the start attribute of the given exception object and place it into
- *start. start must not be NULL. Return 0 on success, -1 on
- failure."""
- raise NotImplementedError
- @cpython_api([PyObject, Py_ssize_t], rffi.INT_real, error=-1)
- def PyUnicodeDecodeError_SetStart(space, exc, start):
- """Set the start attribute of the given exception object to start. Return
- 0 on success, -1 on failure."""
- raise NotImplementedError
- @cpython_api([PyObject, Py_ssize_t], rffi.INT_real, error=-1)
- def PyUnicodeDecodeError_GetEnd(space, exc, end):
- """Get the end attribute of the given exception object and place it into
- *end. end must not be NULL. Return 0 on success, -1 on
- failure."""
- raise NotImplementedError
- @cpython_api([PyObject, Py_ssize_t], rffi.INT_real, error=-1)
- def PyUnicodeDecodeError_SetEnd(space, exc, end):
- """Set the end attribute of the given exception object to end. Return 0
- on success, -1 on failure."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyUnicodeDecodeError_GetReason(space, exc):
- """Return the reason attribute of the given exception object."""
- raise NotImplementedError
- @cpython_api([PyObject, rffi.CCHARP], rffi.INT_real, error=-1)
- def PyUnicodeDecodeError_SetReason(space, exc, reason):
- """Set the reason attribute of the given exception object to reason. Return
- 0 on success, -1 on failure."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP], rffi.INT_real, error=1)
- def Py_EnterRecursiveCall(space, where):
- """Marks a point where a recursive C-level call is about to be performed.
- If USE_STACKCHECK is defined, this function checks if the the OS
- stack overflowed using PyOS_CheckStack(). In this is the case, it
- sets a MemoryError and returns a nonzero value.
- The function then checks if the recursion limit is reached. If this is the
- case, a RuntimeError is set and a nonzero value is returned.
- Otherwise, zero is returned.
- where should be a string such as " in instance check" to be
- concatenated to the RuntimeError message caused by the recursion depth
- limit."""
- raise NotImplementedError
- @cpython_api([], lltype.Void)
- def Py_LeaveRecursiveCall(space):
- """Ends a Py_EnterRecursiveCall(). Must be called once for each
- successful invocation of Py_EnterRecursiveCall()."""
- raise NotImplementedError
- @cpython_api([PyFileObject], lltype.Void)
- def PyFile_IncUseCount(space, p):
- """Increments the PyFileObject's internal use count to indicate
- that the underlying FILE* is being used.
- This prevents Python from calling f_close() on it from another thread.
- Callers of this must call PyFile_DecUseCount() when they are
- finished with the FILE*. Otherwise the file object will
- never be closed by Python.
- The GIL must be held while calling this function.
- The suggested use is to call this after PyFile_AsFile() and before
- you release the GIL:
- FILE *fp = PyFile_AsFile(p);
- PyFile_IncUseCount(p);
- /* ... */
- Py_BEGIN_ALLOW_THREADS
- do_something(fp);
- Py_END_ALLOW_THREADS
- /* ... */
- PyFile_DecUseCount(p);
- """
- raise NotImplementedError
- @cpython_api([PyFileObject], lltype.Void)
- def PyFile_DecUseCount(space, p):
- """Decrements the PyFileObject's internal unlocked_count member to
- indicate that the caller is done with its own use of the FILE*.
- This may only be called to undo a prior call to PyFile_IncUseCount().
- The GIL must be held while calling this function (see the example
- above).
- """
- raise NotImplementedError
- @cpython_api([PyFileObject, rffi.CCHARP], rffi.INT_real, error=0)
- def PyFile_SetEncoding(space, p, enc):
- """Set the file's encoding for Unicode output to enc. Return 1 on success and 0
- on failure.
- """
- raise NotImplementedError
- @cpython_api([PyFileObject, rffi.CCHARP, rffi.CCHARP], rffi.INT_real, error=0)
- def PyFile_SetEncodingAndErrors(space, p, enc, errors):
- """Set the file's encoding for Unicode output to enc, and its error
- mode to err. Return 1 on success and 0 on failure.
- """
- raise NotImplementedError
- @cpython_api([], PyObject)
- def PyFloat_GetInfo(space):
- """Return a structseq instance which contains information about the
- precision, minimum and maximum values of a float. It's a thin wrapper
- around the header file float.h.
- """
- raise NotImplementedError
- @cpython_api([], rffi.DOUBLE, error=CANNOT_FAIL)
- def PyFloat_GetMax(space):
- """Return the maximum representable finite float DBL_MAX as C double.
- """
- raise NotImplementedError
- @cpython_api([], rffi.DOUBLE, error=CANNOT_FAIL)
- def PyFloat_GetMin(space):
- """Return the minimum normalized positive float DBL_MIN as C double.
- """
- raise NotImplementedError
- @cpython_api([], rffi.INT_real, error=CANNOT_FAIL)
- def PyFloat_ClearFreeList(space):
- """Clear the float free list. Return the number of items that could not
- be freed.
- """
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, PyFloatObject], lltype.Void)
- def PyFloat_AsString(space, buf, v):
- """Convert the argument v to a string, using the same rules as
- str(). The length of buf should be at least 100.
- This function is unsafe to call because it writes to a buffer whose
- length it does not know.
- Use PyObject_Str() or PyOS_double_to_string() instead."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, PyFloatObject], lltype.Void)
- def PyFloat_AsReprString(space, buf, v):
- """Same as PyFloat_AsString, except uses the same rules as
- repr(). The length of buf should be at least 100.
- This function is unsafe to call because it writes to a buffer whose
- length it does not know.
- Use PyObject_Repr() or PyOS_double_to_string() instead."""
- raise NotImplementedError
- @cpython_api([PyObject, PyObject], PyObject)
- def PyFunction_New(space, code, globals):
- """Return a new function object associated with the code object code. globals
- must be a dictionary with the global variables accessible to the function.
- The function's docstring, name and __module__ are retrieved from the code
- object, the argument defaults and closure are set to NULL."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyFunction_GetGlobals(space, op):
- """Return the globals dictionary associated with the function object op."""
- borrow_from()
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyFunction_GetModule(space, op):
- """Return the __module__ attribute of the function object op. This is normally
- a string containing the module name, but can be set to any other object by
- Python code."""
- borrow_from()
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyFunction_GetDefaults(space, op):
- """Return the argument default values of the function object op. This can be a
- tuple of arguments or NULL."""
- borrow_from()
- raise NotImplementedError
- @cpython_api([PyObject, PyObject], rffi.INT_real, error=-1)
- def PyFunction_SetDefaults(space, op, defaults):
- """Set the argument default values for the function object op. defaults must be
- Py_None or a tuple.
- Raises SystemError and returns -1 on failure."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyFunction_GetClosure(space, op):
- """Return the closure associated with the function object op. This can be NULL
- or a tuple of cell objects."""
- borrow_from()
- raise NotImplementedError
- @cpython_api([PyObject, PyObject], rffi.INT_real, error=-1)
- def PyFunction_SetClosure(space, op, closure):
- """Set the closure associated with the function object op. closure must be
- Py_None or a tuple of cell objects.
- Raises SystemError and returns -1 on failure."""
- raise NotImplementedError
- @cpython_api([PyTypeObjectPtr, Py_ssize_t], PyObject)
- def PyObject_GC_NewVar(space, type, size):
- """Analogous to PyObject_NewVar() but for container objects with the
- Py_TPFLAGS_HAVE_GC flag set.
- This function used an int type for size. This might require
- changes in your code for properly supporting 64-bit systems."""
- raise NotImplementedError
- @cpython_api([PyObject, Py_ssize_t], PyObject)
- def PyObject_GC_Resize(space, op, newsize):
- """Resize an object allocated by PyObject_NewVar(). Returns the
- resized object or NULL on failure.
- This function used an int type for newsize. This might
- require changes in your code for properly supporting 64-bit systems."""
- raise NotImplementedError
- @cpython_api([PyObject], lltype.Void)
- def _PyObject_GC_TRACK(space, op):
- """A macro version of PyObject_GC_Track(). It should not be used for
- extension modules."""
- raise NotImplementedError
- @cpython_api([PyObject], lltype.Void)
- def _PyObject_GC_UNTRACK(space, op):
- """A macro version of PyObject_GC_UnTrack(). It should not be used for
- extension modules."""
- raise NotImplementedError
- @cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
- def PyGen_Check(space, ob):
- """Return true if ob is a generator object; ob must not be NULL."""
- raise NotImplementedError
- @cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
- def PyGen_CheckExact(space, ob):
- """Return true if ob's type is PyGen_Type is a generator object; ob must not
- be NULL."""
- raise NotImplementedError
- @cpython_api([PyFrameObject], PyObject)
- def PyGen_New(space, frame):
- """Create and return a new generator object based on the frame object. A
- reference to frame is stolen by this function. The parameter must not be
- NULL."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, PyObject, PyObject, PyObject], PyObject)
- def PyImport_ImportModuleEx(space, name, globals, locals, fromlist):
- """Import a module. This is best described by referring to the built-in
- Python function __import__(), as the standard __import__() function calls
- this function directly.
- The return value is a new reference to the imported module or top-level package,
- or NULL with an exception set on failure (before Python 2.4, the module may
- still be created in this case). Like for __import__(), the return value
- when a submodule of a package was requested is normally the top-level package,
- unless a non-empty fromlist was given.
- Failing imports remove incomplete module objects.
- The function is an alias for PyImport_ImportModuleLevel() with
- -1 as level, meaning relative import."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, PyObject, PyObject, PyObject, rffi.INT_real], PyObject)
- def PyImport_ImportModuleLevel(space, name, globals, locals, fromlist, level):
- """Import a module. This is best described by referring to the built-in Python
- function __import__(), as the standard __import__() function calls
- this function directly.
- The return value is a new reference to the imported module or top-level package,
- or NULL with an exception set on failure. Like for __import__(),
- the return value when a submodule of a package was requested is normally the
- top-level package, unless a non-empty fromlist was given.
- """
- raise NotImplementedError
- @cpython_api([], lltype.Signed, error=CANNOT_FAIL)
- def PyImport_GetMagicNumber(space):
- """Return the magic number for Python bytecode files (a.k.a. .pyc and
- .pyo files). The magic number should be present in the first four bytes
- of the bytecode file, in little-endian byte order."""
- raise NotImplementedError
- @cpython_api([PyObject], PyObject)
- def PyImport_GetImporter(space, path):
- """Return an importer object for a sys.path/pkg.__path__ item
- path, possibly by fetching it from the sys.path_importer_cache
- dict. If it wasn't yet cached, traverse sys.path_hooks until a hook
- is found that can handle the path item. Return None if no hook could;
- this tells our caller it should fall back to the built-in import mechanism.
- Cache the result in sys.path_importer_cache. Return a new reference
- to the importer object.
- """
- raise NotImplementedError
- @cpython_api([], lltype.Void)
- def _PyImport_Init(space):
- """Initialize the import mechanism. For internal use only."""
- raise NotImplementedError
- @cpython_api([], lltype.Void)
- def PyImport_Cleanup(space):
- """Empty the module table. For internal use only."""
- raise NotImplementedError
- @cpython_api([], lltype.Void)
- def _PyImport_Fini(space):
- """Finalize the import mechanism. For internal use only."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, rffi.CCHARP], PyObject)
- def _PyImport_FindExtension(space, name, filename):
- """For internal use only."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, rffi.CCHARP], PyObject)
- def _PyImport_FixupExtension(space, name, filename):
- """For internal use only."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP], rffi.INT_real, error=-1)
- def PyImport_ImportFrozenModule(space, name):
- """Load a frozen module named name. Return 1 for success, 0 if the
- module is not found, and -1 with an exception set if the initialization
- failed. To access the imported module on a successful load, use
- PyImport_ImportModule(). (Note the misnomer --- this function would
- reload the module if it was already imported.)"""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP, rffi.VOIDP], rffi.INT_real, error=-1)
- def PyImport_AppendInittab(space, name, initfunc):
- """Add a single module to the existing table of built-in modules. This is a
- convenience wrapper around PyImport_ExtendInittab(), returning -1 if
- the table could not be extended. The new module can be imported by the name
- name, and uses the function initfunc as the initialization function called
- on the first attempted import. This should be called before
- Py_Initialize()."""
- raise NotImplementedError
- @cpython_api([_inittab], rffi.INT_real, error=-1)
- def PyImport_ExtendInittab(space, newtab):
- """Add a collection of modules to the table of built-in modules. The newtab
- array must end with a sentinel entry which contains NULL for the name
- field; failure to provide the sentinel value can result in a memory fault.
- Returns 0 on success or -1 if insufficient memory could be allocated to
- extend the internal table. In the event of failure, no modules are added to the
- internal table. This should be called before Py_Initialize()."""
- raise NotImplementedError
- @cpython_api([], lltype.Void)
- def Py_Initialize(space):
- """Initialize the Python interpreter. In an application embedding Python,
- this should be called before using any other Python/C API functions; with
- the exception of Py_SetProgramName(), PyEval_InitThreads(),
- PyEval_ReleaseLock(), and PyEval_AcquireLock(). This initializes the table
- of loaded modules (sys.modules), and creates the fundamental modules
- __builtin__, __main__ and sys. It also initializes the module search path
- (sys.path). It does not set sys.argv; use PySys_SetArgvEx() for that. This
- is a no-op when called for a second time (without calling Py_Finalize()
- first). There is no return value; it is a fatal error if the initialization
- fails."""
- raise NotImplementedError
- @cpython_api([rffi.INT_real], lltype.Void)
- def Py_InitializeEx(space, initsigs):
- """This function works like Py_Initialize() if initsigs is 1. If
- initsigs is 0, it skips initialization registration of signal handlers, which
- might be useful when Python is embedded.
- """
- raise NotImplementedError
- @cpython_api([], lltype.Void)
- def Py_Finalize(space):
- """Undo all initializations made by Py_Initialize() and subsequent use of
- Python/C API functions, and destroy all sub-interpreters (see
- Py_NewInterpreter() below) that were created and not yet destroyed since
- the last call to Py_Initialize(). Ideally, this frees all memory
- allocated by the Python interpreter. This is a no-op when called for a second
- time (without calling Py_Initialize() again first). There is no return
- value; errors during finalization are ignored.
- This function is provided for a number of reasons. An embedding application
- might want to restart Python without having to restart the application itself.
- An application that has loaded the Python interpreter from a dynamically
- loadable library (or DLL) might want to free all memory allocated by Python
- before unloading the DLL. During a hunt for memory leaks in an application a
- developer might want to free all memory allocated by Python before exiting from
- the application.
- Bugs and caveats: The destruction of modules and objects in modules is done
- in random order; this may cause destructors (__del__() methods) to fail
- when they depend on other objects (even functions) or modules. Dynamically
- loaded extension modules loaded by Python are not unloaded. Small amounts of
- memory allocated by the Python interpreter may not be freed (if you find a leak,
- please report it). Memory tied up in circular references between objects is not
- freed. Some memory allocated by extension modules may not be freed. Some
- extensions may not work properly if their initialization routine is called more
- than once; this can happen if an application calls Py_Initialize() and
- Py_Finalize() more than once."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP], lltype.Void)
- def Py_SetProgramName(space, name):
- """This function should be called before Py_Initialize() is called for the
- first time, if it is called at all. It tells the interpreter the value of
- the argv[0] argument to the main() function of the program. This is used by
- Py_GetPath() and some other functions below to find the Python run-time
- libraries relative to the interpreter executable. The default value is
- 'python'. The argument should point to a zero-terminated character string
- in static storage whose contents will not change for the duration of the
- program's execution. No code in the Python interpreter will change the
- contents of this storage."""
- raise NotImplementedError
- @cpython_api([], rffi.CCHARP)
- def Py_GetPrefix(space):
- """Return the prefix for installed platform-independent files. This is derived
- through a number of complicated rules from the program name set with
- Py_SetProgramName() and some environment variables; for example, if the
- program name is '/usr/local/bin/python', the prefix is '/usr/local'. The
- returned string points into static storage; the caller should not modify its
- value. This corresponds to the prefix variable in the top-level
- Makefile and the --prefix argument to the configure
- script at build time. The value is available to Python code as sys.prefix.
- It is only useful on Unix. See also the next function."""
- raise NotImplementedError
- @cpython_api([], rffi.CCHARP)
- def Py_GetExecPrefix(space):
- """Return the exec-prefix for installed platform-dependent files. This is
- derived through a number of complicated rules from the program name set with
- Py_SetProgramName() and some environment variables; for example, if the
- program name is '/usr/local/bin/python', the exec-prefix is
- '/usr/local'. The returned string points into static storage; the caller
- should not modify its value. This corresponds to the exec_prefix
- variable in the top-level Makefile and the --exec-prefix
- argument to the configure script at build time. The value is
- available to Python code as sys.exec_prefix. It is only useful on Unix.
- Background: The exec-prefix differs from the prefix when platform dependent
- files (such as executables and shared libraries) are installed in a different
- directory tree. In a typical installation, platform dependent files may be
- installed in the /usr/local/plat subtree while platform independent may
- be installed in /usr/local.
- Generally speaking, a platform is a combination of hardware and software
- families, e.g. Sparc machines running the Solaris 2.x operating system are
- considered the same platform, but Intel machines running Solaris 2.x are another
- platform, and Intel machines running Linux are yet another platform. Different
- major revisions of the same operating system generally also form different
- platforms. Non-Unix operating systems are a different story; the installation
- strategies on those systems are so different that the prefix and exec-prefix are
- meaningless, and set to the empty string. Note that compiled Python bytecode
- files are platform independent (but not independent from the Python version by
- which they were compiled!).
- System administrators will know how to configure the mount or
- automount programs to share /usr/local between platforms
- while having /usr/local/plat be a different filesystem for each
- platform."""
- raise NotImplementedError
- @cpython_api([], rffi.CCHARP)
- def Py_GetProgramFullPath(space):
- """Return the full program name of the Python executable; this is computed
- as a side-effect of deriving the default module search path from the program
- name (set by Py_SetProgramName() above). The returned string points into
- static storage; the caller should not modify its value. The value is
- available to Python code as sys.executable."""
- raise NotImplementedError
- @cpython_api([], rffi.CCHARP)
- def Py_GetPath(space):
- """Return the default module search path; this is computed from the program
- name (set by Py_SetProgramName() above) and some environment variables. The
- returned string consists of a series of directory names separated by a
- platform dependent delimiter character. The delimiter character is ':' on
- Unix and Mac OS X, ';' on Windows. The returned string points into static
- storage; the caller should not modify its value. The list sys.path is
- initialized with this value on interpreter startup; it can be (and usually
- is) modified later to change the search path for loading modules.
- XXX should give the exact rules"""
- raise NotImplementedError
- @cpython_api([], rffi.CCHARP)
- def Py_GetPlatform(space):
- """Return the platform identifier for the current platform. On Unix, this
- is formed from the"official" name of the operating system, converted to lower
- case, followed by the major revision number; e.g., for Solaris 2.x, which is
- also known as SunOS 5.x, the value is 'sunos5'. On Mac OS X, it is
- 'darwin'. On Windows, it is 'win'. The returned string points into
- static storage; the caller should not modify its value. The value is available
- to Python code as sys.platform."""
- raise NotImplementedError
- @cpython_api([], rffi.CCHARP)
- def Py_GetCopyright(space):
- """Return the official copyright string for the current Python version, for example
- 'Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam'
- The returned string points into static storage; the caller should not modify its
- value. The value is available to Python code as sys.copyright."""
- raise NotImplementedError
- @cpython_api([], rffi.CCHARP)
- def Py_GetCompiler(space):
- """Return an indication of the compiler used to build the current Python version,
- in square brackets, for example:
- "[GCC 2.7.2.2]"
- The returned string points into static storage; the caller should not modify its
- value. The value is available to Python code as part of the variable
- sys.version."""
- raise NotImplementedError
- @cpython_api([], rffi.CCHARP)
- def Py_GetBuildInfo(space):
- """Return information about the sequence number and build date and time of the
- current Python interpreter instance, for example
- "\#67, Aug 1 1997, 22:34:28"
- The returned string points into static storage; the caller should not modify its
- value. The value is available to Python code as part of the variable
- sys.version."""
- raise NotImplementedError
- @cpython_api([rffi.INT_real, rffi.CCHARPP, rffi.INT_real], lltype.Void)
- def PySys_SetArgvEx(space, argc, argv, updatepath):
- """Set sys.argv based on argc and argv. These parameters are similar to
- those passed to the program's main() function with the difference that the
- first entry should refer to the script file to be executed rather than the
- executable hosting the Python interpreter. If there isn't a script that
- will be run, the first entry in argv can be an empty string. If this
- function fails to initialize sys.argv, a fatal condition is signalled using
- Py_FatalError().
- If updatepath is zero, this is all the function does. If updatepath
- is non-zero, the function also modifies sys.path according to the
- following algorithm:
- If the name of an existing script is passed in argv[0], the absolute
- path of the directory where the script is located is prepended to
- sys.path.
- Otherwise (that is, if argc is 0 or argv[0] doesn't point
- to an existing file name), an empty string is prepended to
- sys.path, which is the same as prepending the current working
- directory (".").
- It is recommended that applications embedding the Python interpreter
- for purposes other than executing a single script pass 0 as updatepath,
- and update sys.path themselves if desired.
- See CVE-2008-5983.
- On versions before 2.6.6, you can achieve the same effect by manually
- popping the first sys.path element after having called
- PySys_SetArgv(), for example using:
- PyRun_SimpleString("import sys; sys.path.pop(0)\n");
- XXX impl. doesn't seem consistent in allowing 0/NULL for the params;
- check w/ Guido."""
- raise NotImplementedError
- @cpython_api([rffi.INT_real, rffi.CCHARPP], lltype.Void)
- def PySys_SetArgv(space, argc, argv):
- """This function works like PySys_SetArgvEx() with updatepath set to 1."""
- raise NotImplementedError
- @cpython_api([rffi.CCHARP], lltype.Void)
- def Py_SetPythonHome(space, home):
- """Set the default "home" directory, that is, the location of the standard
- Python libraries. See PYTHONHOME for the meaning of the
- argument string.
- The argument should point to a zero-terminated character string in static
- storage whose contents will not change for the duration of the program's
- execution. No code in the Python interpreter will change the contents of
- this storage."""
- raise NotImplementedError
- @cpython_api([], rffi.CCHARP)
- def Py_GetPythonHome(space):
- "…
Large files files are truncated, but you can click here to view the full file