/pypy/module/cpyext/stubs.py

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([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):
    """Return the default "home", that is, the value set by a previous call to
    Py_SetPythonHome(), or the value of the PYTHONHOME
    en…