+
cdef extern from "Python.h":
- ctypedef void PyObject
############################################################################
# 7.2.2 Boolean Objects
-# Please see the Python header files (object.h) for docs
-
-from python_ref cimport PyObject
+# Please see the Python header files (object.h/abstract.h) for docs
cdef extern from "Python.h":
- ctypedef struct bufferinfo:
- void *buf
- Py_ssize_t len
- Py_ssize_t itemsize
- int readonly
- int ndim
- char *format
- Py_ssize_t *shape
- Py_ssize_t *strides
- Py_ssize_t *suboffsets
- void *internal
- ctypedef bufferinfo Py_buffer
cdef enum:
PyBUF_SIMPLE,
PyBUF_WRITE,
PyBUF_SHADOW
- int PyObject_CheckBuffer(PyObject* obj)
- int PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
- void PyObject_ReleaseBuffer(PyObject *obj, Py_buffer *view)
+ int PyObject_CheckBuffer(object obj)
+ int PyObject_GetBuffer(object obj, Py_buffer *view, int flags)
+ void PyObject_ReleaseBuffer(object obj, Py_buffer *view)
void* PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)
int PyBuffer_SizeFromFormat(char *) # actually const char
int PyBuffer_ToContiguous(void *buf, Py_buffer *view, Py_ssize_t len, char fort)
int PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)
- int PyObject_CopyData(PyObject *dest, PyObject *src)
+ int PyObject_CopyData(object dest, object src)
int PyBuffer_IsContiguous(Py_buffer *view, char fort)
void PyBuffer_FillContiguousStrides(int ndims,
Py_ssize_t *shape,
Py_ssize_t len, int readonly,
int flags)
- PyObject* PyObject_Format(PyObject* obj,
- PyObject *format_spec)
+ object PyObject_Format(object obj,
+ object format_spec)
+from python_ref cimport PyObject
+
cdef extern from "Python.h":
- ctypedef void PyObject
###########################################################################
# Warning:
+
cdef extern from "Python.h":
- ctypedef void PyObject
ctypedef struct Py_complex
############################################################################
+from python_ref cimport PyObject
+
cdef extern from "Python.h":
- ctypedef void PyObject
+
############################################################################
# 7.4.1 Dictionary Objects
############################################################################
+
# PyDictObject
- # This subtype of PyObject represents a Python dictionary object.
+ #
+ # This subtype of PyObject represents a Python dictionary object
+ # (i.e. the 'dict' type).
+
# PyTypeObject PyDict_Type
- # This instance of PyTypeObject represents the Python dictionary type. This is exposed to Python programs as dict and types.DictType.
+ #
+ # This instance of PyTypeObject represents the Python dictionary
+ # type. This is exposed to Python programs as dict and
+ # types.DictType.
bint PyDict_Check(object p)
# Return true if p is a dict object or an instance of a subtype of
void PyDict_Clear(object p)
# Empty an existing dictionary of all key-value pairs.
- int PyDict_Contains(object p, object key)
+ int PyDict_Contains(object p, object key) except -1
# Determine if dictionary p contains key. If an item in p is
# matches key, return 1, otherwise return 0. On error, return
# -1. This is equivalent to the Python expression "key in p".
# Return value: New reference.
# Return a new dictionary that contains the same key-value pairs as p.
- int PyDict_SetItem(object p, object key, object val)
+ int PyDict_SetItem(object p, object key, object val) except -1
# Insert value into the dictionary p with a key of key. key must
# be hashable; if it isn't, TypeError will be raised. Return 0 on
# success or -1 on failure.
- int PyDict_SetItemString(object p, char *key, object val)
+ int PyDict_SetItemString(object p, char *key, object val) except -1
# Insert value into the dictionary p using key as a key. key
# should be a char*. The key object is created using
# PyString_FromString(key). Return 0 on success or -1 on failure.
- int PyDict_DelItem(object p, object key)
+ int PyDict_DelItem(object p, object key) except -1
# Remove the entry in dictionary p with key key. key must be
# hashable; if it isn't, TypeError is raised. Return 0 on success
# or -1 on failure.
- int PyDict_DelItemString(object p, char *key)
+ int PyDict_DelItemString(object p, char *key) except -1
# Remove the entry in dictionary p which has a key specified by
# the string key. Return 0 on success or -1 on failure.
# Python Library Reference).
Py_ssize_t PyDict_Size(object p)
- # Return the number of items in the dictionary. This is equivalent to "len(p)" on a dictionary.
+ # Return the number of items in the dictionary. This is equivalent
+ # to "len(p)" on a dictionary.
int PyDict_Next(object p, Py_ssize_t *ppos, PyObject* *pkey, PyObject* *pvalue)
# Iterate over all key-value pairs in the dictionary p. The int
# Py_DECREF(o);
# }
- int PyDict_Merge(object a, object b, int override)
+ int PyDict_Merge(object a, object b, int override) except -1
# 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,
# matching key in a. Return 0 on success or -1 if an exception was
# raised.
- int PyDict_Update(object a, object b)
+ int PyDict_Update(object a, object b) except -1
# This is the same as PyDict_Merge(a, b, 1) in C, or a.update(b)
# in Python. Return 0 on success or -1 if an exception was raised.
- int PyDict_MergeFromSeq2(object a, object seq2, int override)
+ int PyDict_MergeFromSeq2(object a, object seq2, int override) except -1
# 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
+from python_ref cimport PyObject
+
cdef extern from "Python.h":
- ctypedef void PyObject
#####################################################################
# 3. Exception Handling
cdef extern from "Python.h":
- ctypedef void PyObject
############################################################################
# 7.2.3
############################################################################
# PyFloatObject
- # This subtype of PyObject represents a Python floating point object.
+ #
+ # This subtype of PyObject represents a Python floating point object.
+
# PyTypeObject PyFloat_Type
- # This instance of PyTypeObject represents the Python floating point type. This is the same object as float and types.FloatType.
+ #
+ # This instance of PyTypeObject represents the Python floating
+ # point type. This is the same object as float and
+ # types.FloatType.
bint PyFloat_Check(object p)
# Return true if its argument is a PyFloatObject or a subtype of
# Create a PyFloatObject object from v, or NULL on failure.
double PyFloat_AsDouble(object pyfloat)
- # Return a C double representation of the contents of pyfloat.
+ # Return a C double representation of the contents of pyfloat.
double PyFloat_AS_DOUBLE(object pyfloat)
- # Return a C double representation of the contents of pyfloat, but without error checking.
+ # Return a C double representation of the contents of pyfloat, but
+ # without error checking.
+from python_ref cimport PyObject
+
cdef extern from "Python.h":
- ctypedef void PyObject
+
############################################################################
# 7.5.3 Function Objects
############################################################################
# There are a few functions specific to Python functions.
+
# PyFunctionObject
- # The C structure used for functions.
+ #
+ # The C structure used for functions.
+
# PyTypeObject PyFunction_Type
+ #
# This is an instance of PyTypeObject and represents the Python
# function type. It is exposed to Python programmers as
# types.FunctionType.
# Return the argument default values of the function object
# op. This can be a tuple of arguments or NULL.
- int PyFunction_SetDefaults(object op, object defaults)
+ int PyFunction_SetDefaults(object op, object defaults) except -1
# 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.
# Return the closure associated with the function object op. This
# can be NULL or a tuple of cell objects.
- int PyFunction_SetClosure(object op, object closure)
+ int PyFunction_SetClosure(object op, object closure) except -1
# 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.
cdef extern from "Python.h":
- ctypedef void PyObject
############################################################################
# 7.5.2 Instance Objects
############################################################################
+
# PyTypeObject PyInstance_Type
- # Type object for class instances.
- # int PyInstance_Check(PyObject *obj)
+ #
+ # Type object for class instances.
+
+ int PyInstance_Check(object obj)
# Return true if obj is an instance.
- object PyInstance_New(PyObject* cls, object arg, object kw)
+ object PyInstance_New(object cls, object arg, object kw)
# Return value: New reference.
# Create a new instance of a specific class. The parameters arg
# and kw are used as the positional and keyword parameters to the
cdef extern from "Python.h":
- ctypedef void PyObject
+ ctypedef unsigned long long PY_LONG_LONG
############################################################################
# Integer Objects
# Create a new integer object with a value of ival. If the value
# exceeds LONG_MAX, a long integer object is returned.
- long PyInt_AsLong(object io)
+ long PyInt_AsLong(object io) except? -1
# Will first attempt to cast the object to a PyIntObject, if it is
# not already one, and then return its value. If there is an
# error, -1 is returned, and the caller should check
# value as unsigned long. This function does not check for
# overflow.
- ctypedef unsigned long long PY_LONG_LONG
PY_LONG_LONG PyInt_AsUnsignedLongLongMask(object io)
# Will first attempt to cast the object to a PyIntObject or
# PyLongObject, if it is not already one, and then return its
############################################################################
# 6.5 Iterator Protocol
############################################################################
- int PyIter_Check(object o)
+ bint PyIter_Check(object o)
# Return true if the object o supports the iterator protocol.
object PyIter_Next(object o)
+from python_ref cimport PyObject
+
cdef extern from "Python.h":
- ctypedef void PyObject
############################################################################
# Lists
############################################################################
object PyList_New(Py_ssize_t len)
- # Return a new list of length len on success, or NULL on
- # failure. Note: If length is greater than zero, the returned list
- # object's items are set to NULL. Thus you cannot use abstract API
+ # Return a new list of length len on success, or NULL on failure.
+ #
+ # Note: If length is greater than zero, the returned list object's
+ # items are set to NULL. Thus you cannot use abstract API
# functions such as PySequence_SetItem() or expose the object to
# Python code before setting all items to a real object with
# PyList_SetItem().
bint PyList_Check(object p)
- # Return true if p is a list object or an instance of a subtype of the list type.
+ # Return true if p is a list object or an instance of a subtype of
+ # the list type.
bint PyList_CheckExact(object p)
- # Return true if p is a list object, but not an instance of a subtype of the list type.
+ # 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)
- # Return the length of the list object in list; this is equivalent to "len(list)" on a list object.
+ # 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.
# Return value: Borrowed reference.
# Macro form of PyList_GetItem() without error checking.
- int PyList_SetItem(object list, Py_ssize_t index, object item)
+ int PyList_SetItem(object list, Py_ssize_t index, object item) except -1
# Set the item at index index in list to item. Return 0 on success
# or -1 on failure. Note: This function ``steals'' a reference to
# item and discards a reference to an item already in the list at
# to any item that it being replaced; any reference in list at
# position i will be *leaked*.
- int PyList_Insert(object list, Py_ssize_t index, object item)
+ int PyList_Insert(object list, Py_ssize_t index, object item) except -1
# Insert the item item into list list in front of index
# index. Return 0 if successful; return -1 and set an exception if
# unsuccessful. Analogous to list.insert(index, item).
- int PyList_Append(object list, object item)
+ int PyList_Append(object list, object item) except -1
# Append the object item at the end of list list. Return 0 if
# successful; return -1 and set an exception if
# unsuccessful. Analogous to list.append(item).
# between low and high. Return NULL and set an exception if
# unsuccessful. Analogous to list[low:high].
- int PyList_SetSlice(object list, Py_ssize_t low, Py_ssize_t high, object itemlist)
+ int PyList_SetSlice(object list, Py_ssize_t low, Py_ssize_t high, object itemlist) except -1
# Set the slice of list between low and high to the contents of
# itemlist. Analogous to list[low:high] = itemlist. The itemlist
# may be NULL, indicating the assignment of an empty list (slice
# deletion). Return 0 on success, -1 on failure.
- int PyList_Sort(object list)
+ int PyList_Sort(object list) except -1
# Sort the items of list in place. Return 0 on success, -1 on
# failure. This is equivalent to "list.sort()".
- int PyList_Reverse(object list)
+ int PyList_Reverse(object list) except -1
# Reverse the items of list in place. Return 0 on success, -1 on
# failure. This is the equivalent of "list.reverse()".
+from python_unicode cimport Py_UNICODE
+
cdef extern from "Python.h":
- ctypedef void PyObject
- ctypedef long PY_LONG_LONG
+ ctypedef long long PY_LONG_LONG
+ ctypedef unsigned long long uPY_LONG_LONG
############################################################################
# 7.2.3 Long Integer Objects
############################################################################
+
# PyLongObject
- # This subtype of PyObject represents a Python long integer object.
+ #
+ # This subtype of PyObject represents a Python long integer object.
+
# PyTypeObject PyLong_Type
+ #
# This instance of PyTypeObject represents the Python long integer
# type. This is the same object as long and types.LongType.
# Return value: New reference.
# Return a new PyLongObject object from a C long long, or NULL on failure.
- object PyLong_FromUnsignedLongLong(PY_LONG_LONG v)
- #PyObject* PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG v)
+ object PyLong_FromUnsignedLongLong(uPY_LONG_LONG v)
# Return value: New reference.
# Return a new PyLongObject object from a C unsigned long long, or NULL on failure.
# inclusive. Leading spaces are ignored. If there are no digits,
# ValueError will be raised.
-
- # object PyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base)
+ object PyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base)
# Return value: New reference.
# Convert a sequence of Unicode digits to a Python long integer
# value. The first parameter, u, points to the first character of
# cannot be represented as a long long, an OverflowError will be
# raised.
- PY_LONG_LONG PyLong_AsUnsignedLongLong(object pylong)
+ uPY_LONG_LONG PyLong_AsUnsignedLongLong(object pylong)
#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
# Return a C unsigned long from a Python long integer, without
# checking for overflow.
- PY_LONG_LONG PyLong_AsUnsignedLongLongMask(object io)
+ uPY_LONG_LONG PyLong_AsUnsignedLongLongMask(object io)
#unsigned PY_LONG_LONG PyLong_AsUnsignedLongLongMask(object io)
# Return a C unsigned long long from a Python long integer,
# without checking for overflow.
-
- double PyLong_AsDouble(object pylong)
+ double PyLong_AsDouble(object pylong) except? -1.0
# Return a C double representation of the contents of pylong. If
# pylong cannot be approximately represented as a double, an
# OverflowError exception is raised and -1.0 will be returned.
cdef extern from "Python.h":
- ctypedef void PyObject
############################################################################
# 6.4 Mapping Protocol
# Return 1 if the object provides mapping protocol, and 0
# otherwise. This function always succeeds.
- Py_ssize_t PyMapping_Length(object o)
+ Py_ssize_t PyMapping_Length(object o) except -1
# Returns the number of keys in object o on success, and -1 on
# failure. For objects that do not provide mapping protocol, this
# is equivalent to the Python expression "len(o)".
- int PyMapping_DelItemString(object o, char *key)
+ int PyMapping_DelItemString(object o, char *key) except -1
# Remove the mapping for object key from the object o. Return -1
# on failure. This is equivalent to the Python statement "del
# o[key]".
- int PyMapping_DelItem(object o, object key)
+ int PyMapping_DelItem(object o, object key) except -1
# Remove the mapping for object key from the object o. Return -1
# on failure. This is equivalent to the Python statement "del
# o[key]".
# failure. This is the equivalent of the Python expression
# "o[key]".
- int PyMapping_SetItemString(object o, char *key, object v)
+ int PyMapping_SetItemString(object o, char *key, object v) except -1
# Map the object key to the value v in object o. Returns -1 on
# failure. This is the equivalent of the Python statement "o[key]
# = v".
+from python_ref cimport PyObject
+
cdef extern from "Python.h":
- ctypedef void PyObject
ctypedef struct _inittab
#####################################################################
# the reloaded module, or NULL with an exception set on failure
# (the module still exists in this case).
- PyObject* PyImport_AddModule(char *name)
+ PyObject* PyImport_AddModule(char *name) except NULL
# Return value: Borrowed reference.
# Return the module object corresponding to a module name. The
# name argument may be of the form package.module. First check the
# variable.
- int PyImport_ImportFrozenModule(char *name)
+ int PyImport_ImportFrozenModule(char *name) except -1
# 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
# imported.)
- int PyImport_ExtendInittab(_inittab *newtab)
+ int PyImport_ExtendInittab(_inittab *newtab) except -1
# 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
#####################################################################
# 7.5.5 Module Objects
#####################################################################
+
# PyTypeObject PyModule_Type
+ #
# This instance of PyTypeObject represents the Python module
# type. This is exposed to Python programs as types.ModuleType.
bint PyModule_CheckExact(object p)
# Return true if p is a module object, but not a subtype of PyModule_Type.
- object PyModule_New( char *name)
+ object PyModule_New(char *name)
# Return value: New reference.
# Return a new module object with the __name__ attribute set to
# name. Only the module's __doc__ and __name__ attributes are
# use other PyModule_*() and PyObject_*() functions rather than
# directly manipulate a module's __dict__.
- char* PyModule_GetName(object module)
+ char* PyModule_GetName(object module) except NULL
# Return module's __name__ value. If the module does not provide
# one, or if it is not a string, SystemError is raised and NULL is
# returned.
- char* PyModule_GetFilename(object module)
+ char* PyModule_GetFilename(object module) except NULL
# Return the name of the file from which module was loaded using
# module's __file__ attribute. If this is not defined, or if it is
# not a string, raise SystemError and return NULL.
- int PyModule_AddObject(object module, char *name, object value)
+ int PyModule_AddObject(object module, char *name, object value) except -1
# Add an object to module as name. This is a convenience function
# which can be used from the module's initialization
# function. This steals a reference to value. Return -1 on error,
# 0 on success.
- int PyModule_AddIntant(object module, char *name, long value)
+ int PyModule_AddIntant(object module, char *name, long value) except -1
# Add an integer ant to module as name. This convenience
# function can be used from the module's initialization
# function. Return -1 on error, 0 on success.
- int PyModule_AddStringant(object module, char *name, char *value)
+ int PyModule_AddStringant(object module, char *name, char *value) except -1
# Add a string constant to module as name. This convenience
# function can be used from the module's initialization
# function. The string value must be null-terminated. Return -1 on
+from python_ref cimport PyObject
+
cdef extern from "Python.h":
- ctypedef void PyObject
- ctypedef void PyTypeObject
- ctypedef struct FILE
-
#####################################################################
# 6.2 Number Protocol
# failure. The operation is done in-place when o1 supports
# it. This is the equivalent of the Python statement "o1 |= o2".
- int PyNumber_Coerce(PyObject **p1, PyObject **p2)
+ int PyNumber_Coerce(PyObject **p1, PyObject **p2) except -1
# This function takes the addresses of two variables of type
# PyObject*. If the objects pointed to by *p1 and *p2 have the
# same type, increment their reference count and return 0
# integer or PY_SSIZE_T_MAX for a positive integer.
bint PyIndex_Check(object o)
- # Returns True if o is an index integer (has the nb_index slot of the tp_as_number structure filled in).
+ # Returns True if o is an index integer (has the nb_index slot of
+ # the tp_as_number structure filled in).
-from python_ref cimport PyObject
+from python_ref cimport PyObject, PyTypeObject
+from stdio cimport FILE
cdef extern from "Python.h":
- ctypedef void PyTypeObject
- ctypedef struct FILE
#####################################################################
# 6.1 Object Protocol
#####################################################################
- int PyObject_Print(object o, FILE *fp, int flags)
+ int PyObject_Print(object o, FILE *fp, int flags) except -1
# Print an object o, on file fp. Returns -1 on error. The flags
# argument is used to enable certain printing options. The only
# option currently supported is Py_PRINT_RAW; if given, the str()
# or NULL on failure. This is the equivalent of the Python
# expression "o.attr_name".
- int PyObject_SetAttrString(object o, char *attr_name, object v)
+ int PyObject_SetAttrString(object o, char *attr_name, object v) except -1
# Set the value of the attribute named attr_name, for object o, to
# the value v. Returns -1 on failure. This is the equivalent of
# the Python statement "o.attr_name = v".
- int PyObject_SetAttr(object o, object attr_name, object v)
+ int PyObject_SetAttr(object o, object attr_name, object v) except -1
# Set the value of the attribute named attr_name, for object o, to
# the value v. Returns -1 on failure. This is the equivalent of
# the Python statement "o.attr_name = v".
- int PyObject_DelAttrString(object o, char *attr_name)
+ int PyObject_DelAttrString(object o, char *attr_name) except -1
# Delete attribute named attr_name, for object o. Returns -1 on
# failure. This is the equivalent of the Python statement: "del
# o.attr_name".
- int PyObject_DelAttr(object o, object attr_name)
+ int PyObject_DelAttr(object o, object attr_name) except -1
# Delete attribute named attr_name, for object o. Returns -1 on
# failure. This is the equivalent of the Python statement "del
# o.attr_name".
# opid. Returns the value of the comparison on success, or NULL on
# failure.
- int PyObject_RichCompareBool(object o1, object o2, int opid)
+ bint PyObject_RichCompareBool(object o1, object o2, int opid) except -1
# Compare the values of o1 and o2 using the operation specified by
# opid, which must be one of Py_LT, Py_LE, Py_EQ, Py_NE, Py_GT, or
# Py_GE, corresponding to <, <=, ==, !=, >, or >=
# otherwise. This is the equivalent of the Python expression "o1
# op o2", where op is the operator corresponding to opid.
- int PyObject_Cmp(object o1, object o2, int *result)
+ int PyObject_Cmp(object o1, object o2, int *result) except -1
# Compare the values of o1 and o2 using a routine provided by o1,
# if one exists, otherwise with a routine provided by o2. The
# result of the comparison is returned in result. Returns -1 on
# failure. This is the equivalent of the Python statement "result
# = cmp(o1, o2)".
- int PyObject_Compare(object o1, object o2)
+ int PyObject_Compare(object o1, object o2) except *
# Compare the values of o1 and o2 using a routine provided by o1,
# if one exists, otherwise with a routine provided by o2. Returns
# the result of the comparison on success. On error, the value
# is the equivalent of the Python expression "unicode(o)". Called
# by the unicode() built-in function.
- bint PyObject_IsInstance(object inst, object cls)
+ bint PyObject_IsInstance(object inst, object cls) except -1
# Returns 1 if inst is an instance of the class cls or a subclass
# of cls, or 0 if not. On error, returns -1 and sets an
# exception. If cls is a type object rather than a class object,
# fashion for A -- the presence of the __bases__ attribute is
# considered sufficient for this determination.
- bint PyObject_IsSubclass(object derived, object cls)
+ bint PyObject_IsSubclass(object derived, object cls) except -1
# Returns 1 if the class derived is identical to or derived from
# the class cls, otherwise returns 0. In case of an error, returns
# -1. If cls is a tuple, the check will be done against every
# NULL. Returns the result of the call on success, or NULL on
# failure.
- long PyObject_Hash(object o)
+ long PyObject_Hash(object o) except? -1
# Compute and return the hash value of an object o. On failure,
# return -1. This is the equivalent of the Python expression
# "hash(o)".
- bint PyObject_IsTrue(object o)
+ bint PyObject_IsTrue(object o) except -1
# Returns 1 if the object o is considered to be true, and 0
# otherwise. This is equivalent to the Python expression "not not
# o". On failure, return -1.
- bint PyObject_Not(object o)
+ bint PyObject_Not(object o) except -1
# Returns 0 if the object o is considered to be true, and 1
# otherwise. This is equivalent to the Python expression "not
# o". On failure, return -1.
# Return true if the object o is of type type or a subtype of
# type. Both parameters must be non-NULL.
- Py_ssize_t PyObject_Length(object o)
- Py_ssize_t PyObject_Size(object o)
+ Py_ssize_t PyObject_Length(object o) except -1
+ Py_ssize_t PyObject_Size(object o) except -1
# Return the length of object o. If the object o provides either
# the sequence and mapping protocols, the sequence length is
# returned. On error, -1 is returned. This is the equivalent to
# failure. This is the equivalent of the Python expression
# "o[key]".
- int PyObject_SetItem(object o, object key, object v)
+ int PyObject_SetItem(object o, object key, object v) except -1
# Map the object key to the value v. Returns -1 on failure. This
# is the equivalent of the Python statement "o[key] = v".
- int PyObject_DelItem(object o, object key)
+ int PyObject_DelItem(object o, object key) except -1
# Delete the mapping for key from o. Returns -1 on failure. This
# is the equivalent of the Python statement "del o[key]".
- int PyObject_AsFileDescriptor(object o)
+ int PyObject_AsFileDescriptor(object o) except -1
# Derives a file-descriptor from a Python object. If the object is
# an integer or long integer, its value is returned. If not, the
# object's fileno() method is called if it exists; the method must
--- /dev/null
+from python_ref cimport PyObject
+
+# available since Python 3.1!
+
+# note all char* in the below functions are actually const char*
+
+cdef extern from "Python.h":
+
+ ctypedef struct PyCapsule_Type
+ # This subtype of PyObject represents an opaque value, useful for
+ # C extension modules who need to pass an opaque value (as a void*
+ # pointer) through Python code to other C code. It is often used
+ # to make a C function pointer defined in one module available to
+ # other modules, so the regular import mechanism can be used to
+ # access C APIs defined in dynamically loaded modules.
+
+
+ ctypedef void (*PyCapsule_Destructor)(object o)
+ # The type of a destructor callback for a capsule.
+ #
+ # See PyCapsule_New() for the semantics of PyCapsule_Destructor
+ # callbacks.
+
+
+ bint PyCapsule_CheckExact(object o)
+ # Return true if its argument is a PyCapsule.
+
+
+ object PyCapsule_New(void *pointer, char *name,
+ PyCapsule_Destructor destructor)
+ # Return value: New reference.
+ #
+ # Create a PyCapsule encapsulating the pointer. The pointer
+ # argument may not be NULL.
+ #
+ # On failure, set an exception and return NULL.
+ #
+ # The name string may either be NULL or a pointer to a valid C
+ # string. If non-NULL, this string must outlive the
+ # capsule. (Though it is permitted to free it inside the
+ # destructor.)
+ #
+ # If the destructor argument is not NULL, it will be called with
+ # the capsule as its argument when it is destroyed.
+ #
+ # If this capsule will be stored as an attribute of a module, the
+ # name should be specified as modulename.attributename. This will
+ # enable other modules to import the capsule using
+ # PyCapsule_Import().
+
+
+ void* PyCapsule_GetPointer(object capsule, char *name)
+ # Retrieve the pointer stored in the capsule. On failure, set an
+ # exception and return NULL.
+ #
+ # The name parameter must compare exactly to the name stored in
+ # the capsule. If the name stored in the capsule is NULL, the name
+ # passed in must also be NULL. Python uses the C function strcmp()
+ # to compare capsule names.
+
+
+ PyCapsule_Destructor PyCapsule_GetDestructor(object capsule)
+ # Return the current destructor stored in the capsule. On failure,
+ # set an exception and return NULL.
+ #
+ # It is legal for a capsule to have a NULL destructor. This makes
+ # a NULL return code somewhat ambiguous; use PyCapsule_IsValid()
+ # or PyErr_Occurred() to disambiguate.
+
+
+ char* PyCapsule_GetName(object capsule)
+ # Return the current name stored in the capsule. On failure, set
+ # an exception and return NULL.
+ #
+ # It is legal for a capsule to have a NULL name. This makes a NULL
+ # return code somewhat ambiguous; use PyCapsule_IsValid() or
+ # PyErr_Occurred() to disambiguate.
+
+
+ void* PyCapsule_GetContext(object capsule)
+ # Return the current context stored in the capsule. On failure,
+ # set an exception and return NULL.
+ #
+ # It is legal for a capsule to have a NULL context. This makes a
+ # NULL return code somewhat ambiguous; use PyCapsule_IsValid() or
+ # PyErr_Occurred() to disambiguate.
+
+
+ int 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 parameter. (See PyCapsule_GetPointer() for information on
+ # how capsule names are compared.)
+ #
+ # In other words, if PyCapsule_IsValid() returns a true value,
+ # calls to any of the accessors (any function starting with
+ # PyCapsule_Get()) are guaranteed to succeed.
+ #
+ # Return a nonzero value if the object is valid and matches the
+ # name passed in. Return 0 otherwise. This function will not fail.
+
+
+ int PyCapsule_SetPointer(object capsule, void *pointer)
+ # Set the void pointer inside capsule to pointer. The pointer may
+ # not be NULL.
+ #
+ # Return 0 on success. Return nonzero and set an exception on
+ # failure.
+
+
+ int PyCapsule_SetDestructor(object capsule, PyCapsule_Destructor destructor)
+ # 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)
+ # 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.
+ #
+ # Return 0 on success. Return nonzero and set an exception on
+ # failure.
+
+
+ int PyCapsule_SetContext(object capsule, void *context)
+ # 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)
+ # 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
+ # capsule must match this string exactly. If no_block is true,
+ # import the module without blocking (using
+ # PyImport_ImportModuleNoBlock()). If no_block is false, import
+ # the module conventionally (using PyImport_ImportModule()).
+ #
+ # Return the capsule’s internal pointer on success. On failure,
+ # set an exception and return NULL. However, if PyCapsule_Import()
+ # failed to import the module, and no_block was true, no exception
+ # is set.
+
cdef extern from "Python.h":
- ctypedef void PyTypeObject
+ ctypedef struct PyTypeObject
ctypedef struct PyObject:
Py_ssize_t ob_refcnt
PyTypeObject *ob_type
- ############################################################################
- # 6.3 Sequence Protocol
- ############################################################################
+from python_ref cimport PyObject
cdef extern from "Python.h":
- ctypedef void PyObject
+ ############################################################################
+ # 6.3 Sequence Protocol
+ ############################################################################
bint PySequence_Check(object o)
# Return 1 if the object provides sequence protocol, and 0
# otherwise. This function always succeeds.
- Py_ssize_t PySequence_Size(object o)
+ Py_ssize_t PySequence_Size(object o) except -1
# Returns the number of objects in sequence o on success, and -1
# on failure. For objects that do not provide sequence protocol,
# this is equivalent to the Python expression "len(o)".
- Py_ssize_t PySequence_Length(object o)
+ Py_ssize_t PySequence_Length(object o) except -1
# Alternate name for PySequence_Size().
object PySequence_Concat(object o1, object o2)
# on failure. This is the equivalent of the Python expression
# "o[i1:i2]".
- int PySequence_SetItem(object o, Py_ssize_t i, object v)
+ int PySequence_SetItem(object o, Py_ssize_t i, object v) except -1
# Assign object v to the ith element of o. Returns -1 on
# failure. This is the equivalent of the Python statement "o[i] =
# v". This function does not steal a reference to v.
- int PySequence_DelItem(object o, Py_ssize_t i)
+ int PySequence_DelItem(object o, Py_ssize_t i) except -1
# Delete the ith element of object o. Returns -1 on failure. This
# is the equivalent of the Python statement "del o[i]".
- int PySequence_SetSlice(object o, Py_ssize_t i1, Py_ssize_t i2, object v)
+ int PySequence_SetSlice(object o, Py_ssize_t i1, Py_ssize_t i2, object v) except -1
# Assign the sequence object v to the slice in sequence object o
# from i1 to i2. This is the equivalent of the Python statement
# "o[i1:i2] = v".
- int PySequence_DelSlice(object o, Py_ssize_t i1, Py_ssize_t i2)
+ int PySequence_DelSlice(object o, Py_ssize_t i1, Py_ssize_t i2) except -1
# Delete the slice in sequence object o from i1 to i2. Returns -1
# on failure. This is the equivalent of the Python statement "del
# o[i1:i2]".
- int PySequence_Count(object o, object value)
+ int PySequence_Count(object o, object value) except -1
# Return the number of occurrences of value in o, that is, return
# the number of keys for which o[key] == value. On failure, return
# -1. This is equivalent to the Python expression
# "o.count(value)".
- int PySequence_Contains(object o, object value)
+ int PySequence_Contains(object o, object value) except -1
# Determine if o contains value. If an item in o is equal to
# value, return 1, otherwise return 0. On error, return -1. This
# is equivalent to the Python expression "value in o".
- int PySequence_Index(object o, object value)
+ int PySequence_Index(object o, object value) except -1
# Return the first index i for which o[i] == value. On error,
# return -1. This is equivalent to the Python expression
# "o.index(value)".
cdef extern from "Python.h":
- ctypedef void PyObject
############################################################################
# 7.5.14 Set Objects
# frozenset. Return the new set on success or NULL on
# failure. Raise TypeError if iterable is not actually iterable.
- # The following functions and macros are available for instances of set or frozenset or instances of their subtypes.
- int PySet_Size(object anyset)
+ # The following functions and macros are available for instances
+ # of set or frozenset or instances of their subtypes.
+
+ int PySet_Size(object anyset) except -1
# Return the length of a set or frozenset object. Equivalent to
# "len(anyset)". Raises a PyExc_SystemError if anyset is not a
# set, frozenset, or an instance of a subtype.
int PySet_GET_SIZE(object anyset)
# Macro form of PySet_Size() without error checking.
- int PySet_Contains(object anyset, object key)
+ bint PySet_Contains(object anyset, object key) except -1
# Return 1 if found, 0 if not found, and -1 if an error is
# encountered. Unlike the Python __contains__() method, this
# function does not automatically convert unhashable sets into
# unhashable. Raise PyExc_SystemError if anyset is not a set,
# frozenset, or an instance of a subtype.
+
# The following functions are available for instances of set or
# its subtypes but not for instances of frozenset or its subtypes.
- int PySet_Add(object set, object key)
+ int PySet_Add(object set, object key) except -1
# Add key to a set instance. Does not apply to frozenset
# instances. Return 0 on success or -1 on failure. Raise a
# TypeError if the key is unhashable. Raise a MemoryError if there
# is no room to grow. Raise a SystemError if set is an not an
# instance of set or its subtype.
- int PySet_Discard(object set, object key)
+ bint PySet_Discard(object set, object key) except -1
# Return 1 if found and removed, 0 if not found (no action taken),
# and -1 if an error is encountered. Does not raise KeyError for
# missing keys. Raise a TypeError if the key is unhashable. Unlike
# frozensets. Raise PyExc_SystemError if set is an not an instance
# of set or its subtype.
- PySet_Pop(object set)
+ object PySet_Pop(object set)
# Return value: New reference.
# Return a new reference to an arbitrary object in the set, and
# removes the object from the set. Return NULL on failure. Raise
int PySet_Clear(object set)
# Empty an existing set of all elements.
-
+from python_ref cimport PyObject
+
cdef extern from "Python.h":
- ctypedef void PyObject
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
Py_ssize_t PyString_GET_SIZE(object string)
# Macro form of PyString_Size() but without error checking.
- char* PyString_AsString(object string)
+ char* PyString_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
# checking. Only string objects are supported; no Unicode objects
# should be passed.
- int PyString_AsStringAndSize(object obj, char **buffer, Py_ssize_t *length)
+ int PyString_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.
#
# newpart appended to string. This version decrements the
# reference count of newpart.
- int _PyString_Resize(PyObject **string, Py_ssize_t newsize)
+ int _PyString_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
+from python_ref cimport PyObject
+
cdef extern from "Python.h":
- ctypedef void PyObject
############################################################################
# Tuples
# Return the size of the tuple p, which must be non-NULL and point
# to a tuple; no error checking is performed.
- PyObject* PyTuple_GetItem(object p, Py_ssize_t pos)
+ PyObject* PyTuple_GetItem(object p, Py_ssize_t pos) except NULL
# Return value: Borrowed reference.
# Return the object at position pos in the tuple pointed to by
# p. If pos is out of bounds, return NULL and sets an IndexError
# only be used to fill in brand new tuples. Note: This function
# ``steals'' a reference to o.
- int _PyTuple_Resize(PyObject **p, Py_ssize_t newsize)
+ int _PyTuple_Resize(PyObject **p, Py_ssize_t newsize) except -1
# Can be used to resize a tuple. newsize will be the new length of
# the tuple. Because tuples are supposed to be immutable, this
# should only be used if there is only one reference to the
+
cdef extern from "Python.h":
- ctypedef void PyObject
- ctypedef void PyTypeObject
# The C structure of the objects used to describe built-in types.
############################################################################
object PyType_GenericNew(object type, object args, object kwds)
# Return value: New reference.
- bint PyType_Ready(object type)
+ bint PyType_Ready(object type) except -1
# Finalize a type object. This should be called on all type
# objects to finish their initialization. This function is
# responsible for adding inherited slots from a type's base
cdef extern from *:
- ctypedef int Py_UNICODE
+ ctypedef unsigned int Py_UNICODE
# Return true if the object o is a Unicode object or an instance
# of a Unicode subtype. Changed in version 2.2: Allowed subtypes
projects / cython.git / commitdiff