# fastest). If fortran is 'A', then it does not matter and the
# copy will be made in whatever way is more efficient.
- int PyObject_CopyData(object dest, object src)
+ int PyObject_CopyData(object dest, object src) except -1
# Copy the data from the src buffer to the buffer of destination
bint PyBuffer_IsContiguous(Py_buffer *view, char fort)
--- /dev/null
+from python_ref cimport PyObject
+
+cdef extern from "Python.h":
+ ctypedef struct va_list
+
+ ############################################################################
+ # 7.3.1 String Objects
+ ############################################################################
+
+ # These functions raise TypeError when expecting a string
+ # parameter and are called with a non-string parameter.
+ # PyStringObject
+ # This subtype of PyObject represents a Python bytes object.
+ # PyTypeObject PyBytes_Type
+ # This instance of PyTypeObject represents the Python bytes type;
+ # it is the same object as bytes and types.BytesType in the Python
+ # layer.
+
+ bint PyBytes_Check(object o)
+ # Return true if the object o is a string object or an instance of
+ # a subtype of the string type.
+
+ bint PyBytes_CheckExact(object o)
+ # Return true if the object o is a string object, but not an instance of a subtype of the string type.
+
+ object PyBytes_FromString(char *v)
+ # Return value: New reference.
+ # Return a new string object with the value v on success, and NULL
+ # on failure. The parameter v must not be NULL; it will not be
+ # checked.
+
+ object PyBytes_FromStringAndSize(char *v, Py_ssize_t len)
+ # Return value: New reference.
+ # Return a new string object with the value v and length len on
+ # success, and NULL on failure. If v is NULL, the contents of the
+ # string are uninitialized.
+
+ object PyBytes_FromFormat(char *format, ...)
+ # Return value: New reference.
+ # Take a C printf()-style format string and a variable number of
+ # arguments, calculate the size of the resulting Python string and
+ # return a string with the values formatted into it. The variable
+ # arguments must be C types and must correspond exactly to the
+ # format characters in the format string. The following format
+ # characters are allowed:
+ # Format Characters Type Comment
+ # %% n/a The literal % character.
+ # %c int A single character, represented as an C int.
+ # %d int Exactly equivalent to printf("%d").
+ # %u unsigned int Exactly equivalent to printf("%u").
+ # %ld long Exactly equivalent to printf("%ld").
+ # %lu unsigned long Exactly equivalent to printf("%lu").
+ # %zd Py_ssize_t Exactly equivalent to printf("%zd").
+ # %zu size_t Exactly equivalent to printf("%zu").
+ # %i int Exactly equivalent to printf("%i").
+ # %x int Exactly equivalent to printf("%x").
+ # %s char* A null-terminated C character array.
+
+ # %p void* The hex representation of a C pointer.
+ # Mostly equivalent to printf("%p") except that it is guaranteed to
+ # start with the literal 0x regardless of what the platform's printf
+ # yields.
+ # An unrecognized format character causes all the rest of the
+ # format string to be copied as-is to the result string, and any
+ # extra arguments discarded.
+
+ object PyBytes_FromFormatV(char *format, va_list vargs)
+ # Return value: New reference.
+ # Identical to PyBytes_FromFormat() except that it takes exactly two arguments.
+
+ Py_ssize_t PyBytes_Size(object string) except -1
+ # Return the length of the string in string object string.
+
+ Py_ssize_t PyBytes_GET_SIZE(object string)
+ # Macro form of PyBytes_Size() but without error checking.
+
+ char* PyBytes_AsString(object string) except NULL
+ # Return a NUL-terminated representation of the contents of
+ # string. The pointer refers to the internal buffer of string, not
+ # a copy. The data must not be modified in any way, unless the
+ # string was just created using PyBytes_FromStringAndSize(NULL,
+ # size). It must not be deallocated. If string is a Unicode
+ # object, this function computes the default encoding of string
+ # and operates on that. If string is not a string object at all,
+ # PyBytes_AsString() returns NULL and raises TypeError.
+
+ char* PyBytes_AS_STRING(object string)
+ # Macro form of PyBytes_AsString() but without error
+ # checking. Only string objects are supported; no Unicode objects
+ # should be passed.
+
+ int PyBytes_AsStringAndSize(object obj, char **buffer, Py_ssize_t *length) except -1
+ # Return a NULL-terminated representation of the contents of the
+ # object obj through the output variables buffer and length.
+ #
+ # The function accepts both string and Unicode objects as
+ # input. For Unicode objects it returns the default encoded
+ # version of the object. If length is NULL, the resulting buffer
+ # may not contain NUL characters; if it does, the function returns
+ # -1 and a TypeError is raised.
+
+ # The buffer refers to an internal string buffer of obj, not a
+ # copy. The data must not be modified in any way, unless the
+ # string was just created using PyBytes_FromStringAndSize(NULL,
+ # size). It must not be deallocated. If string is a Unicode
+ # object, this function computes the default encoding of string
+ # and operates on that. If string is not a string object at all,
+ # PyBytes_AsStringAndSize() returns -1 and raises TypeError.
+
+ void PyBytes_Concat(PyObject **string, object newpart)
+ # Create a new string object in *string containing the contents of
+ # newpart appended to string; the caller will own the new
+ # reference. The reference to the old value of string will be
+ # stolen. If the new string cannot be created, the old reference
+ # to string will still be discarded and the value of *string will
+ # be set to NULL; the appropriate exception will be set.
+
+ void PyBytes_ConcatAndDel(PyObject **string, object newpart)
+ # Create a new string object in *string containing the contents of
+ # newpart appended to string. This version decrements the
+ # reference count of newpart.
+
+ int _PyBytes_Resize(PyObject **string, Py_ssize_t newsize) except -1
+ # A way to resize a string object even though it is
+ # ``immutable''. Only use this to build up a brand new string
+ # object; don't use this if the string may already be known in
+ # other parts of the code. It is an error to call this function if
+ # the refcount on the input string object is not one. Pass the
+ # address of an existing string object as an lvalue (it may be
+ # written into), and the new size desired. On success, *string
+ # holds the resized string object and 0 is returned; the address
+ # in *string may differ from its input value. If the reallocation
+ # fails, the original string object at *string is deallocated,
+ # *string is set to NULL, a memory exception is set, and -1 is
+ # returned.
+
+ object PyBytes_Format(object format, object args)
+ # Return value: New reference. Return a new string object from
+ # format and args. Analogous to format % args. The args argument
+ # must be a tuple.
+
+ void PyBytes_InternInPlace(PyObject **string)
+ # Intern the argument *string in place. The argument must be the
+ # address of a pointer variable pointing to a Python string
+ # object. If there is an existing interned string that is the same
+ # as *string, it sets *string to it (decrementing the reference
+ # count of the old string object and incrementing the reference
+ # count of the interned string object), otherwise it leaves
+ # *string alone and interns it (incrementing its reference
+ # count). (Clarification: even though there is a lot of talk about
+ # reference counts, think of this function as
+ # reference-count-neutral; you own the object after the call if
+ # and only if you owned it before the call.)
+
+ object PyBytes_InternFromString(char *v)
+ # Return value: New reference.
+ # A combination of PyBytes_FromString() and
+ # PyBytes_InternInPlace(), returning either a new string object
+ # that has been interned, or a new (``owned'') reference to an
+ # earlier interned string object with the same value.
+
+ object PyBytes_Decode(char *s, Py_ssize_t size, char *encoding, char *errors)
+ # Return value: New reference.
+ # Create an object by decoding size bytes of the encoded buffer s
+ # using the codec registered for encoding. encoding and errors
+ # have the same meaning as the parameters of the same name in the
+ # unicode() built-in function. The codec to be used is looked up
+ # using the Python codec registry. Return NULL if an exception was
+ # raised by the codec.
+
+ object PyBytes_AsDecodedObject(object str, char *encoding, char *errors)
+ # Return value: New reference.
+ # Decode a string object by passing it to the codec registered for
+ # encoding and return the result as Python object. encoding and
+ # errors have the same meaning as the parameters of the same name
+ # in the string encode() method. The codec to be used is looked up
+ # using the Python codec registry. Return NULL if an exception was
+ # raised by the codec.
+
+ object PyBytes_Encode(char *s, Py_ssize_t size, char *encoding, char *errors)
+ # Return value: New reference.
+ # Encode the char buffer of the given size by passing it to the
+ # codec registered for encoding and return a Python
+ # object. encoding and errors have the same meaning as the
+ # parameters of the same name in the string encode() method. The
+ # codec to be used is looked up using the Python codec
+ # registry. Return NULL if an exception was raised by the codec.
+
+ object PyBytes_AsEncodedObject(object str, char *encoding, char *errors)
+ # Return value: New reference.
+ # Encode a string object using the codec registered for encoding
+ # and return the result as Python object. encoding and errors have
+ # the same meaning as the parameters of the same name in the
+ # string encode() method. The codec to be used is looked up using
+ # the Python codec registry. Return NULL if an exception was
+ # raised by the codec.
+
+
# be called when the object is reclaimed. The desc argument can be
# used to pass extra callback data for the destructor function.
- void* PyCObject_AsVoidPtr(object self)
+ void* PyCObject_AsVoidPtr(object self) except? NULL
# Return the object void * that the PyCObject self was created with.
- void* PyCObject_GetDesc(object self)
+ void* PyCObject_GetDesc(object self) except? NULL
# Return the description void * that the PyCObject self was created with.
- int PyCObject_SetVoidPtr(object self, void* cobj)
+ int PyCObject_SetVoidPtr(object self, void* cobj) except 0
# Set the void pointer inside self to cobj. The PyCObject must not
# have an associated destructor. Return true on success, false on
# failure.
# Return value: New reference.
# Return a new PyComplexObject object from real and imag.
- double PyComplex_RealAsDouble(object op)
+ double PyComplex_RealAsDouble(object op) except? -1
# Return the real part of op as a C double.
- double PyComplex_ImagAsDouble(object op)
+ double PyComplex_ImagAsDouble(object op) except? -1
# Return the imaginary part of op as a C double.
Py_complex PyComplex_AsCComplex(object op)
- # Return the Py_complex value of the complex number op.
+ # Return the Py_complex value of the complex number op.
+ #
+ # Returns (-1+0i) in case of an error
# dictionary p, as in the dictionary method values() (see the
# Python Library Reference).
- Py_ssize_t PyDict_Size(object p)
+ Py_ssize_t PyDict_Size(object p) except -1
# Return the number of items in the dictionary. This is equivalent
# to "len(p)" on a dictionary.
# of a class, in the case of a class exception, or it may the a
# subclass of the expected exception.)
- int PyErr_ExceptionMatches(object exc)
+ bint PyErr_ExceptionMatches(object exc)
# Equivalent to "PyErr_GivenExceptionMatches(PyErr_Occurred(),
# exc)". This should only be called when an exception is actually
# set; a memory access violation will occur if no exception has
void PyErr_SetNone(object type)
# This is a shorthand for "PyErr_SetObject(type, Py_None)".
- int PyErr_BadArgument()
+ int PyErr_BadArgument() except 0
# This is a shorthand for "PyErr_SetString(PyExc_TypeError,
# message)", where message indicates that a built-in operation was
# (e.g. a Python/C API function) was invoked with an illegal
# argument. It is mostly for internal use.
- int PyErr_WarnEx(object category, char *message, int stacklevel)
+ int PyErr_WarnEx(object category, char *message, int stacklevel) except -1
# Issue a warning message. The category argument is a warning
# category (see below) or NULL; the message argument is a message
# string. stacklevel is a positive number giving a number of stack
# function calling PyErr_WarnEx(), 2 is the function above that,
# and so forth.
- int PyErr_WarnExplicit(object category, char *message, char *filename, int lineno, char *module, object registry)
+ int PyErr_WarnExplicit(object category, char *message, char *filename, int lineno, char *module, object registry) except -1
# 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.
- int PyErr_CheckSignals()
+ int PyErr_CheckSignals() except -1
# This function interacts with Python's signal handling. It checks
# whether a signal has been sent to the processes and if so,
# invokes the corresponding signal handler. If the signal module
# Return value: New reference.
# Create a PyFloatObject object from v, or NULL on failure.
- double PyFloat_AsDouble(object pyfloat)
+ double PyFloat_AsDouble(object pyfloat) except? -1
# Return a C double representation of the contents of pyfloat.
- double PyFloat_AS_DOUBLE(object pyfloat)
+ double PyFloat_AS_DOUBLE(object pyfloat) except? -1
# Return a C double representation of the contents of pyfloat, but
# without error checking.
# the code object, the argument defaults and closure are set to
# NULL.
- PyObject* PyFunction_GetCode(object op)
+ PyObject* PyFunction_GetCode(object op) except? NULL
# Return value: Borrowed reference.
# Return the code object associated with the function object op.
- PyObject* PyFunction_GetGlobals(object op)
+ PyObject* PyFunction_GetGlobals(object op) except? NULL
# Return value: Borrowed reference.
# Return the globals dictionary associated with the function object op.
- PyObject* PyFunction_GetModule(object op)
+ PyObject* PyFunction_GetModule(object op) except? NULL
# Return value: Borrowed reference.
# 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.
- PyObject* PyFunction_GetDefaults(object op)
+ PyObject* PyFunction_GetDefaults(object op) except? NULL
# Return value: Borrowed reference.
# Return the argument default values of the function object
# op. This can be a tuple of arguments or NULL.
# op. defaults must be Py_None or a tuple.
# Raises SystemError and returns -1 on failure.
- PyObject* PyFunction_GetClosure(object op)
+ PyObject* PyFunction_GetClosure(object op) except? NULL
# Return value: Borrowed reference.
# Return the closure associated with the function object op. This
# can be NULL or a tuple of cell objects.
--- /dev/null
+from python_ref cimport PyObject
+
+cdef extern from "Python.h":
+ #####################################################################
+ # 5.5 Parsing arguments and building values
+ #####################################################################
+ ctypedef struct va_list
+ int PyArg_ParseTuple(object args, char *format, ...) except 0
+ int PyArg_VaParse(object args, char *format, va_list vargs) except 0
+ int PyArg_ParseTupleAndKeywords(object args, object kw, char *format, char *keywords[], ...) except 0
+ int PyArg_VaParseTupleAndKeywords(object args, object kw, char *format, char *keywords[], va_list vargs) except 0
+ int PyArg_Parse(object args, char *format, ...) except 0
+ int PyArg_UnpackTuple(object args, char *name, Py_ssize_t min, Py_ssize_t max, ...) except 0
long PyInt_AS_LONG(object io)
# Return the value of the object io. No error checking is performed.
- unsigned long PyInt_AsUnsignedLongMask(object io)
+ unsigned long PyInt_AsUnsignedLongMask(object io) except? -1
# Will first attempt to cast the object to a PyIntObject or
# PyLongObject, if it is not already one, and then return its
# value as unsigned long. This function does not check for
# overflow.
- PY_LONG_LONG PyInt_AsUnsignedLongLongMask(object io)
+ PY_LONG_LONG PyInt_AsUnsignedLongLongMask(object io) except? -1
# Will first attempt to cast the object to a PyIntObject or
# PyLongObject, if it is not already one, and then return its
# value as unsigned long long, without checking for overflow.
- Py_ssize_t PyInt_AsSsize_t(object io)
+ Py_ssize_t PyInt_AsSsize_t(object io) except? -1
# Will first attempt to cast the object to a PyIntObject or
# PyLongObject, if it is not already one, and then return its
# value as Py_ssize_t.
# Return true if p is a list object, but not an instance of a
# subtype of the list type.
- Py_ssize_t PyList_Size(object list)
+ Py_ssize_t PyList_Size(object list) except -1
# Return the length of the list object in list; this is equivalent
# to "len(list)" on a list object.
Py_ssize_t PyList_GET_SIZE(object list)
# Macro form of PyList_Size() without error checking.
- PyObject* PyList_GetItem(object list, Py_ssize_t index)
+ PyObject* PyList_GetItem(object list, Py_ssize_t index) except NULL
# Return value: Borrowed reference.
# Return the object at position pos in the list pointed to by
# p. The position must be positive, indexing from the end of the
# PyLong_AsVoidPtr(). If the integer is larger than LONG_MAX, a
# positive long integer is returned.
- long PyLong_AsLong(object pylong)
+ long PyLong_AsLong(object pylong) except? -1
# Return a C long representation of the contents of pylong. If
# pylong is greater than LONG_MAX, an OverflowError is raised.
- unsigned long PyLong_AsUnsignedLong(object pylong)
+ unsigned long PyLong_AsUnsignedLong(object pylong) except? -1
# Return a C unsigned long representation of the contents of
# pylong. If pylong is greater than ULONG_MAX, an OverflowError is
# raised.
- PY_LONG_LONG PyLong_AsLongLong(object pylong)
+ PY_LONG_LONG PyLong_AsLongLong(object pylong) except? -1
# Return a C long long from a Python long integer. If pylong
# cannot be represented as a long long, an OverflowError will be
# raised.
- uPY_LONG_LONG PyLong_AsUnsignedLongLong(object pylong)
+ uPY_LONG_LONG PyLong_AsUnsignedLongLong(object pylong) except? -1
#unsigned PY_LONG_LONG PyLong_AsUnsignedLongLong(object pylong)
# Return a C unsigned long long from a Python long integer. If
# pylong cannot be represented as an unsigned long long, an
# OverflowError will be raised if the value is positive, or a
# TypeError will be raised if the value is negative.
- unsigned long PyLong_AsUnsignedLongMask(object io)
+ unsigned long PyLong_AsUnsignedLongMask(object io) except? -1
# Return a C unsigned long from a Python long integer, without
# checking for overflow.
- uPY_LONG_LONG PyLong_AsUnsignedLongLongMask(object io)
+ uPY_LONG_LONG PyLong_AsUnsignedLongLongMask(object io) except? -1
#unsigned PY_LONG_LONG PyLong_AsUnsignedLongLongMask(object io)
# Return a C unsigned long long from a Python long integer,
# without checking for overflow.
# pylong cannot be approximately represented as a double, an
# OverflowError exception is raised and -1.0 will be returned.
- void* PyLong_AsVoidPtr(object pylong)
+ void* PyLong_AsVoidPtr(object pylong) except? NULL
# Convert a Python integer or long integer pylong to a C void
# pointer. If pylong cannot be converted, an OverflowError will be
# raised. This is only assured to produce a usable void pointer
# otherwise self should be NULL and class should be the class
# which provides the unbound method..
- PyObject* PyMethod_Class(object meth)
+ PyObject* PyMethod_Class(object meth) except NULL
# Return value: Borrowed reference.
# Return the class object from which the method meth was created;
# if this was created from an instance, it will be the class of
# Return value: Borrowed reference.
# Macro version of PyMethod_Class() which avoids error checking.
- PyObject* PyMethod_Function(object meth)
+ PyObject* PyMethod_Function(object meth) except NULL
# Return value: Borrowed reference.
# Return the function object associated with the method meth.
# Return value: Borrowed reference.
# Macro version of PyMethod_Function() which avoids error checking.
- PyObject* PyMethod_Self(object meth)
+ PyObject* PyMethod_Self(object meth) except? NULL
# Return value: Borrowed reference.
# Return the instance associated with the method meth if it is bound, otherwise return NULL.
# and .pyo files). The magic number should be present in the first
# four bytes of the bytecode file, in little-endian byte order.
- PyObject* PyImport_GetModuleDict()
+ PyObject* PyImport_GetModuleDict() except NULL
# Return value: Borrowed reference.
# Return the dictionary used for the module administration
# (a.k.a. sys.modules). Note that this is a per-interpreter
# filled in; the caller is responsible for providing a __file__
# attribute.
- PyObject* PyModule_GetDict(object module)
+ PyObject* PyModule_GetDict(object module) except NULL
# Return value: Borrowed reference.
# Return the dictionary object that implements module's namespace;
# this object is the same as the __dict__ attribute of the module
# Returns the o converted to a Python int or long on success or
# NULL with a TypeError exception raised on failure.
- Py_ssize_t PyNumber_AsSsize_t(object o, object exc)
+ Py_ssize_t PyNumber_AsSsize_t(object o, object exc) except? -1
# Returns o converted to a Py_ssize_t value if o can be
# interpreted as an integer. If o can be converted to a Python int
# or long but the attempt to convert to a Py_ssize_t value would
+++ /dev/null
-cdef extern from "Python.h":
- ctypedef void PyObject
- #####################################################################
- # 5.5 Parsing arguments and building values
- #####################################################################
- ctypedef struct va_list
- int PyArg_ParseTuple(PyObject *args, char *format, ...)
- int PyArg_VaParse(PyObject *args, char *format, va_list vargs)
- int PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kw, char *format, char *keywords[], ...)
- int PyArg_VaParseTupleAndKeywords(PyObject *args, PyObject *kw, char *format, char *keywords[], va_list vargs)
- int PyArg_Parse(PyObject *args, char *format, ...)
- int PyArg_UnpackTuple(PyObject *args, char *name, Py_ssize_t min, Py_ssize_t max, ...)
-
# PyCapsule_Import().
- void* PyCapsule_GetPointer(object capsule, char *name)
+ void* PyCapsule_GetPointer(object capsule, char *name) except? NULL
# Retrieve the pointer stored in the capsule. On failure, set an
# exception and return NULL.
#
# to compare capsule names.
- PyCapsule_Destructor PyCapsule_GetDestructor(object capsule)
+ PyCapsule_Destructor PyCapsule_GetDestructor(object capsule) except? NULL
# Return the current destructor stored in the capsule. On failure,
# set an exception and return NULL.
#
# or PyErr_Occurred() to disambiguate.
- char* PyCapsule_GetName(object capsule)
+ char* PyCapsule_GetName(object capsule) except? NULL
# Return the current name stored in the capsule. On failure, set
# an exception and return NULL.
#
# PyErr_Occurred() to disambiguate.
- void* PyCapsule_GetContext(object capsule)
+ void* PyCapsule_GetContext(object capsule) except? NULL
# Return the current context stored in the capsule. On failure,
# set an exception and return NULL.
#
# PyErr_Occurred() to disambiguate.
- int PyCapsule_IsValid(object capsule, char *name)
+ bint PyCapsule_IsValid(object capsule, char *name)
# Determines whether or not capsule is a valid capsule. A valid
# capsule is non-NULL, passes PyCapsule_CheckExact(), has a
# non-NULL pointer stored in it, and its internal name matches the
# name passed in. Return 0 otherwise. This function will not fail.
- int PyCapsule_SetPointer(object capsule, void *pointer)
+ int PyCapsule_SetPointer(object capsule, void *pointer) except -1
# Set the void pointer inside capsule to pointer. The pointer may
# not be NULL.
#
# failure.
- int PyCapsule_SetDestructor(object capsule, PyCapsule_Destructor destructor)
+ int PyCapsule_SetDestructor(object capsule, PyCapsule_Destructor destructor) except -1
# Set the destructor inside capsule to destructor.
#
# Return 0 on success. Return nonzero and set an exception on
# failure.
- int PyCapsule_SetName(object capsule, char *name)
+ int PyCapsule_SetName(object capsule, char *name) except -1
# Set the name inside capsule to name. If non-NULL, the name must
# outlive the capsule. If the previous name stored in the capsule
# was not NULL, no attempt is made to free it.
# failure.
- int PyCapsule_SetContext(object capsule, void *context)
+ int PyCapsule_SetContext(object capsule, void *context) except -1
# Set the context pointer inside capsule to context. Return 0 on
# success. Return nonzero and set an exception on failure.
- void* PyCapsule_Import(char *name, int no_block)
+ void* PyCapsule_Import(char *name, int no_block) except? NULL
# Import a pointer to a C object from a capsule attribute in a
# module. The name parameter should specify the full name to the
# attribute, as in module.attribute. The name stored in the
bint PyFrozenSet_CheckExact(object p)
# Return true if p is a frozenset object but not an instance of a subtype.
- PySet_New(object iterable)
+ object PySet_New(object iterable)
# Return value: New reference.
# Return a new set containing objects returned by the
# iterable. The iterable may be NULL to create a new empty
# TypeError if iterable is not actually iterable. The constructor
# is also useful for copying a set (c=set(s)).
- PyFrozenSet_New(object iterable)
+ object PyFrozenSet_New(object iterable)
# Return value: New reference.
# Return a new frozenset containing objects returned by the
# iterable. The iterable may be NULL to create a new empty
# Return value: New reference.
# Identical to PyString_FromFormat() except that it takes exactly two arguments.
- Py_ssize_t PyString_Size(object string)
+ Py_ssize_t PyString_Size(object string) except -1
# Return the length of the string in string object string.
Py_ssize_t PyString_GET_SIZE(object string)
# pointing to Python objects. "PyTuple_Pack(2, a, b)" is
# equivalent to "Py_BuildValue("(OO)", a, b)".
- int PyTuple_Size(object p)
+ int PyTuple_Size(object p) except -1
# Take a pointer to a tuple object, and return the size of that tuple.
int PyTuple_GET_SIZE(object p)
# Return a read-only pointer to the Unicode object's internal
# Py_UNICODE buffer, NULL if unicode is not a Unicode object.
- Py_UNICODE* PyUnicode_AsUnicode(object o)
+ Py_UNICODE* PyUnicode_AsUnicode(object o) except NULL
# Return the length of the Unicode object.
- Py_ssize_t PyUnicode_GetSize(object o)
+ Py_ssize_t PyUnicode_GetSize(object o) except -1
# Coerce an encoded object obj to an Unicode object and return a
# reference with incremented refcount.
projects / cython.git / commitdiff