Originally authored as part of SAGE by William Stein.
--- /dev/null
+#####################################################################
+#
+# These are the "SageX" pxi files for (most of) the Python/C API.
+#
+# SageX = SAGE Pyrex, which is a fork of Pyrex for use in SAGE.
+#
+# REFERENCE COUNTING:
+#
+# JUST TO SCARE YOU:
+# If you are going to use any of the Python/C API in your SageX
+# program, you might be responsible for doing reference counting.
+# Read http://docs.python.org/api/refcounts.html which is so
+# important I've copied it below.
+#
+# For all the declaration below, whenver the Py_ function returns
+# a *new reference* to a PyObject*, the return type is "object".
+# When the function returns a borrowed reference, the return
+# type is PyObject*. When SageX sees "object" as a return type
+# it doesn't increment the reference count. When it sees PyObject*
+# in order to use the result you must explicitly cast to <object>,
+# and when you do that SageX increments the reference count wether
+# you want it to or not, forcing you to an explicit DECREF (or leak memory).
+# To avoid this we make the above convention. Note, you can
+# always locally override this convention by putting something like
+#
+# cdef extern from "Python.h":
+# PyObject* PyNumber_Add(PyObject *o1, PyObject *o2)
+#
+# in your file after any .pxi includes. SageX will use the latest
+# declaration.
+#
+# SageX takes care of this automatically for anything of type object.
+## More precisely, I think the correct convention for
+## using the Python/C API from Pyrex is as follows.
+##
+## (1) Declare all input arguments as type "object". This way no explicit
+## <PyObject*> casting is needed, and moreover Pyrex doesn't generate
+## any funny reference counting.
+## (2) Declare output as object if a new reference is returned.
+## (3) Declare output as PyObject* if a borrowed reference is returned.
+##
+## This way when you call objects, no cast is needed, and if the api
+## calls returns a new reference (which is about 95% of them), then
+## you can just assign to a variable of type object. With borrowed
+## references if you do an explicit typecast to <object>, Pyrex generates an
+## INCREF and DECREF so you have to be careful. However, you got a
+## borrowed reference in this case, so there's got to be another reference
+## to your object, so you're OK, as long as you relealize this
+## and use the result of an explicit cast to <object> as a borrowed
+## reference (and you can call Py_INCREF if you want to turn it
+## into another reference for some reason).
+#
+# "The reference count is important because today's computers have
+# a finite (and often severely limited) memory size; it counts how
+# many different places there are that have a reference to an
+# object. Such a place could be another object, or a global (or
+# static) C variable, or a local variable in some C function. When
+# an object's reference count becomes zero, the object is
+# deallocated. If it contains references to other objects, their
+# reference count is decremented. Those other objects may be
+# deallocated in turn, if this decrement makes their reference
+# count become zero, and so on. (There's an obvious problem with
+# objects that reference each other here; for now, the solution is
+# ``don't do that.'')
+#
+# Reference counts are always manipulated explicitly. The normal
+# way is to use the macro Py_INCREF() to increment an object's
+# reference count by one, and Py_DECREF() to decrement it by
+# one. The Py_DECREF() macro is considerably more complex than the
+# incref one, since it must check whether the reference count
+# becomes zero and then cause the object's deallocator to be
+# called. The deallocator is a function pointer contained in the
+# object's type structure. The type-specific deallocator takes
+# care of decrementing the reference counts for other objects
+# contained in the object if this is a compound object type, such
+# as a list, as well as performing any additional finalization
+# that's needed. There's no chance that the reference count can
+# overflow; at least as many bits are used to hold the reference
+# count as there are distinct memory locations in virtual memory
+# (assuming sizeof(long) >= sizeof(char*)). Thus, the reference
+# count increment is a simple operation.
+#
+# It is not necessary to increment an object's reference count for
+# every local variable that contains a pointer to an object. In
+# theory, the object's reference count goes up by one when the
+# variable is made to point to it and it goes down by one when the
+# variable goes out of scope. However, these two cancel each other
+# out, so at the end the reference count hasn't changed. The only
+# real reason to use the reference count is to prevent the object
+# from being deallocated as long as our variable is pointing to
+# it. If we know that there is at least one other reference to the
+# object that lives at least as long as our variable, there is no
+# need to increment the reference count temporarily. An important
+# situation where this arises is in objects that are passed as
+# arguments to C functions in an extension module that are called
+# from Python; the call mechanism guarantees to hold a reference
+# to every argument for the duration of the call.
+#
+# However, a common pitfall is to extract an object from a list
+# and hold on to it for a while without incrementing its reference
+# count. Some other operation might conceivably remove the object
+# from the list, decrementing its reference count and possible
+# deallocating it. The real danger is that innocent-looking
+# operations may invoke arbitrary Python code which could do this;
+# there is a code path which allows control to flow back to the
+# user from a Py_DECREF(), so almost any operation is potentially
+# dangerous.
+#
+# A safe approach is to always use the generic operations
+# (functions whose name begins with "PyObject_", "PyNumber_",
+# "PySequence_" or "PyMapping_"). These operations always
+# increment the reference count of the object they return. This
+# leaves the caller with the responsibility to call Py_DECREF()
+# when they are done with the result; this soon becomes second
+# nature.
+#
+# Now you should read http://docs.python.org/api/refcountDetails.html
+# just to be sure you understand what is going on.
+#
+#################################################################
+cdef extern from "Python.h":
+ ctypedef void PyObject
+ ctypedef void PyTypeObject
+ ctypedef struct FILE
+
+
+include 'python_ref.pxi'
+include 'python_exc.pxi'
+include 'python_module.pxi'
+include 'python_mem.pxi'
+include 'python_tuple.pxi'
+include 'python_list.pxi'
+include 'python_object.pxi'
+include 'python_sequence.pxi'
+include 'python_mapping.pxi'
+include 'python_iterator.pxi'
+include 'python_type.pxi'
+include 'python_number.pxi'
+include 'python_int.pxi'
+include 'python_bool.pxi'
+include 'python_long.pxi'
+include 'python_float.pxi'
+include 'python_complex.pxi'
+include 'python_string.pxi'
+include 'python_dict.pxi'
+include 'python_instance.pxi'
+include 'python_function.pxi'
+include 'python_method.pxi'
+include 'python_set.pxi'
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+
+ ############################################################################
+ # 7.2.2 Boolean Objects
+ ############################################################################
+
+ # Booleans in Python are implemented as a subclass of
+ # integers. There are only two booleans, Py_False and Py_True. As
+ # such, the normal creation and deletion functions don't apply to
+ # booleans. The following macros are available, however.
+
+ bint PyBool_Check(object o)
+ # Return true if o is of type PyBool_Type.
+
+ #PyObject* Py_False
+ # The Python False object. This object has no methods. It needs to
+ # be treated just like any other object with respect to reference
+ # counts.
+
+ #PyObject* Py_True
+ # The Python True object. This object has no methods. It needs to
+ # be treated just like any other object with respect to reference
+ # counts.
+
+ # Py_RETURN_FALSE
+ # Return Py_False from a function, properly incrementing its reference count.
+
+ # Py_RETURN_TRUE
+ # Return Py_True from a function, properly incrementing its reference count.
+
+ object PyBool_FromLong(long v)
+ # Return value: New reference.
+ # Return a new reference to Py_True or Py_False depending on the truth value of v.
+
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+ ctypedef struct Py_complex
+
+ ############################################################################
+ # 7.2.5.2 Complex Numbers as Python Objects
+ ############################################################################
+
+ # PyComplexObject
+ # This subtype of PyObject represents a Python complex number object.
+
+ # PyTypeObject PyComplex_Type
+ # This instance of PyTypeObject represents the Python complex
+ # number type. It is the same object as complex and
+ # types.ComplexType.
+
+ bint PyComplex_Check(object p)
+ # Return true if its argument is a PyComplexObject or a subtype of
+ # PyComplexObject.
+
+ bint PyComplex_CheckExact(object p)
+ # Return true if its argument is a PyComplexObject, but not a subtype of PyComplexObject.
+
+ object PyComplex_FromCComplex(Py_complex v)
+ # Return value: New reference.
+ # Create a new Python complex number object from a C Py_complex value.
+
+ object PyComplex_FromDoubles(double real, double imag)
+ # Return value: New reference.
+ # Return a new PyComplexObject object from real and imag.
+
+ double PyComplex_RealAsDouble(object op)
+ # Return the real part of op as a C double.
+
+ double PyComplex_ImagAsDouble(object op)
+ # 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.
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+ ############################################################################
+ # 7.4.1 Dictionary Objects
+ ############################################################################
+ # PyDictObject
+ # This subtype of PyObject represents a Python dictionary object.
+ # PyTypeObject PyDict_Type
+ # 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
+ # the dict type.
+
+ bint PyDict_CheckExact(object p)
+ # Return true if p is a dict object, but not an instance of a
+ # subtype of the dict type.
+
+ object PyDict_New()
+ # Return value: New reference.
+ # Return a new empty dictionary, or NULL on failure.
+
+ object PyDictProxy_New(object dict)
+ # Return value: New reference.
+ # Return a proxy object for a mapping which enforces read-only
+ # behavior. This is normally used to create a proxy to prevent
+ # modification of the dictionary for non-dynamic class types.
+
+ void PyDict_Clear(object p)
+ # Empty an existing dictionary of all key-value pairs.
+
+ int PyDict_Contains(object p, object key)
+ # 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".
+
+ object PyDict_Copy(object 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)
+ # 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)
+ # 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)
+ # 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)
+ # Remove the entry in dictionary p which has a key specified by
+ # the string key. Return 0 on success or -1 on failure.
+
+ PyObject* PyDict_GetItem(object p, object key)
+ # Return value: Borrowed reference.
+ # Return the object from dictionary p which has a key key. Return
+ # NULL if the key key is not present, but without setting an
+ # exception.
+
+ PyObject* PyDict_GetItemString(object p, char *key)
+ # Return value: Borrowed reference.
+ # This is the same as PyDict_GetItem(), but key is specified as a
+ # char*, rather than a PyObject*.
+
+ object PyDict_Items(object p)
+ # Return value: New reference.
+ # Return a PyListObject containing all the items from the
+ # dictionary, as in the dictionary method items() (see the Python
+ # Library Reference).
+
+ object PyDict_Keys(object p)
+ # Return value: New reference.
+ # Return a PyListObject containing all the keys from the
+ # dictionary, as in the dictionary method keys() (see the Python
+ # Library Reference).
+
+ object PyDict_Values(object p)
+ # Return value: New reference.
+ # Return a PyListObject containing all the values from the
+ # dictionary p, as in the dictionary method values() (see the
+ # 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.
+
+ 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
+ # referred to by ppos must be initialized to 0 prior to the first
+ # call to this function to start the iteration; the function
+ # returns true for each pair in the dictionary, and false once all
+ # pairs have been reported. The parameters pkey and pvalue should
+ # either point to PyObject* variables that will be filled in with
+ # each key and value, respectively, or may be NULL. Any references
+ # returned through them are borrowed. ppos should not be altered
+ # during iteration. Its value represents offsets within the
+ # internal dictionary structure, and since the structure is
+ # sparse, the offsets are not consecutive.
+ # For example:
+ #
+ #object key, *value;
+ #int pos = 0;
+ #
+ #while (PyDict_Next(self->dict, &pos, &key, &value)) {
+ # /* do something interesting with the values... */
+ # ...
+ #}
+ # The dictionary p should not be mutated during iteration. It is
+ # safe (since Python 2.1) to modify the values of the keys as you
+ # iterate over the dictionary, but only so long as the set of keys
+ # does not change. For example:
+ # object key, *value;
+ # int pos = 0;
+ # while (PyDict_Next(self->dict, &pos, &key, &value)) {
+ # int i = PyInt_AS_LONG(value) + 1;
+ # object o = PyInt_FromLong(i);
+ # if (o == NULL)
+ # return -1;
+ # if (PyDict_SetItem(self->dict, key, o) < 0) {
+ # Py_DECREF(o);
+ # return -1;
+ # }
+ # Py_DECREF(o);
+ # }
+
+ int PyDict_Merge(object a, object b, int 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.
+
+ int PyDict_Update(object a, object b)
+ # 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)
+ # 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
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+
+ #####################################################################
+ # 3. Exception Handling
+ #####################################################################
+
+ # The functions described in this chapter will let you handle and
+ # raise Python exceptions. It is important to understand some of
+ # the basics of Python exception handling. It works somewhat like
+ # the Unix errno variable: there is a global indicator (per
+ # thread) of the last error that occurred. Most functions don't
+ # clear this on success, but will set it to indicate the cause of
+ # the error on failure. Most functions also return an error
+ # indicator, usually NULL if they are supposed to return a
+ # pointer, or -1 if they return an integer (exception: the
+ # PyArg_*() functions return 1 for success and 0 for failure).
+
+ # When a function must fail because some function it called
+ # failed, it generally doesn't set the error indicator; the
+ # function it called already set it. It is responsible for either
+ # handling the error and clearing the exception or returning after
+ # cleaning up any resources it holds (such as object references or
+ # memory allocations); it should not continue normally if it is
+ # not prepared to handle the error. If returning due to an error,
+ # it is important to indicate to the caller that an error has been
+ # set. If the error is not handled or carefully propagated,
+ # additional calls into the Python/C API may not behave as
+ # intended and may fail in mysterious ways.
+
+ # The error indicator consists of three Python objects
+ # corresponding to the Python variables sys.exc_type,
+ # sys.exc_value and sys.exc_traceback. API functions exist to
+ # interact with the error indicator in various ways. There is a
+ # separate error indicator for each thread.
+
+ void PyErr_Print()
+ # Print a standard traceback to sys.stderr and clear the error
+ # indicator. Call this function only when the error indicator is
+ # set. (Otherwise it will cause a fatal error!)
+
+ PyObject* PyErr_Occurred()
+ # Return value: Borrowed reference.
+ # Test whether the error indicator is set. If set, return the
+ # exception type (the first argument to the last call to one of
+ # the PyErr_Set*() functions or to PyErr_Restore()). If not set,
+ # return NULL. You do not own a reference to the return value, so
+ # you do not need to Py_DECREF() it. Note: Do not compare the
+ # return value to a specific exception; use
+ # PyErr_ExceptionMatches() instead, shown below. (The comparison
+ # could easily fail since the exception may be an instance instead
+ # 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)
+ # 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
+ # been raised.
+
+ bint PyErr_GivenExceptionMatches(object given, object exc)
+ # Return true if the given exception matches the exception in
+ # exc. If exc is a class object, this also returns true when given
+ # is an instance of a subclass. If exc is a tuple, all exceptions
+ # in the tuple (and recursively in subtuples) are searched for a
+ # match. If given is NULL, a memory access violation will occur.
+
+ void PyErr_NormalizeException(PyObject** exc, PyObject** val, PyObject** tb)
+ # Under certain circumstances, the values returned by
+ # PyErr_Fetch() below can be ``unnormalized'', meaning that *exc
+ # is a class object but *val is not an instance of the same
+ # class. This function can be used to instantiate the class in
+ # that case. If the values are already normalized, nothing
+ # happens. The delayed normalization is implemented to improve
+ # performance.
+
+ void PyErr_Clear()
+ # Clear the error indicator. If the error indicator is not set, there is no effect.
+
+ void PyErr_Fetch(PyObject** ptype, PyObject** pvalue, PyObject** ptraceback)
+ # Retrieve the error indicator into three variables whose
+ # addresses are passed. If the error indicator is not set, set all
+ # three variables to NULL. If it is set, it will be cleared and
+ # you own a reference to each object retrieved. The value and
+ # traceback object may be NULL even when the type object is
+ # not. Note: This function is normally only used by code that
+ # needs to handle exceptions or by code that needs to save and
+ # restore the error indicator temporarily.
+
+ void PyErr_Restore(object type, object value, object traceback)
+ # Set the error indicator from the three objects. If the error
+ # indicator is already set, it is cleared first. If the objects
+ # are NULL, the error indicator is cleared. Do not pass a NULL
+ # type and non-NULL value or traceback. The exception type should
+ # be a class. Do not pass an invalid exception type or
+ # value. (Violating these rules will cause subtle problems later.)
+ # This call takes away a reference to each object: you must own a
+ # reference to each object before the call and after the call you
+ # no longer own these references. (If you don't understand this,
+ # don't use this function. I warned you.) Note: This function is
+ # normally only used by code that needs to save and restore the
+ # error indicator temporarily; use PyErr_Fetch() to save the
+ # current exception state.
+
+ void PyErr_SetString(object type, char *message)
+ # This is the most common way to set the error indicator. The
+ # first argument specifies the exception type; it is normally one
+ # of the standard exceptions, e.g. PyExc_RuntimeError. You need
+ # not increment its reference count. The second argument is an
+ # error message; it is converted to a string object.
+
+ void PyErr_SetObject(object type, object value)
+ # This function is similar to PyErr_SetString() but lets you
+ # specify an arbitrary Python object for the ``value'' of the
+ # exception.
+
+ PyObject* PyErr_Format(object exception, char *format, ...)
+ # Return value: Always NULL.
+ # This function sets the error indicator and returns
+ # NULL. exception should be a Python exception (class, not an
+ # instance). format should be a string, containing format codes,
+ # similar to printf(). The width.precision before a format code is
+ # parsed, but the width part is ignored.
+
+ void PyErr_SetNone(object type)
+ # This is a shorthand for "PyErr_SetObject(type, Py_None)".
+
+ int PyErr_BadArgument()
+
+ # This is a shorthand for "PyErr_SetString(PyExc_TypeError,
+ # message)", where message indicates that a built-in operation was
+ # invoked with an illegal argument. It is mostly for internal use.
+
+ PyObject* PyErr_NoMemory()
+ # Return value: Always NULL.
+ # This is a shorthand for "PyErr_SetNone(PyExc_MemoryError)"; it
+ # returns NULL so an object allocation function can write "return
+ # PyErr_NoMemory();" when it runs out of memory.
+
+ PyObject* PyErr_SetFromErrno(object type)
+ # Return value: Always NULL.
+ # This is a convenience function to raise an exception when a C
+ # library function has returned an error and set the C variable
+ # errno. It constructs a tuple object whose first item is the
+ # integer errno value and whose second item is the corresponding
+ # error message (gotten from strerror()), and then calls
+ # "PyErr_SetObject(type, object)". On Unix, when the errno value
+ # is EINTR, indicating an interrupted system call, this calls
+ # PyErr_CheckSignals(), and if that set the error indicator,
+ # leaves it set to that. The function always returns NULL, so a
+ # wrapper function around a system call can write "return
+ # PyErr_SetFromErrno(type);" when the system call returns an
+ # error.
+
+ PyObject* PyErr_SetFromErrnoWithFilename(object type, char *filename)
+ # Return value: Always NULL. Similar to PyErr_SetFromErrno(),
+ # with the additional behavior that if filename is not NULL, it is
+ # passed to the constructor of type as a third parameter. In the
+ # case of exceptions such as IOError and OSError, this is used to
+ # define the filename attribute of the exception instance.
+
+ PyObject* PyErr_SetFromWindowsErr(int ierr)
+ # Return value: Always NULL. 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.
+
+ PyObject* PyErr_SetExcFromWindowsErr(object type, int ierr)
+ # Return value: Always NULL. Similar to
+ # PyErr_SetFromWindowsErr(), with an additional parameter
+ # specifying the exception type to be raised. Availability:
+ # Windows. New in version 2.3.
+
+ PyObject* PyErr_SetFromWindowsErrWithFilename(int ierr, char *filename)
+ # Return value: Always NULL. 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.
+
+ PyObject* PyErr_SetExcFromWindowsErrWithFilename(object type, int ierr, char *filename)
+ # Return value: Always NULL.
+ # Similar to PyErr_SetFromWindowsErrWithFilename(), with an
+ # additional parameter specifying the exception type to be
+ # raised. Availability: Windows.
+
+ void PyErr_BadInternalCall()
+ # This is a shorthand for "PyErr_SetString(PyExc_TypeError,
+ # message)", where message indicates that an internal operation
+ # (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)
+ # 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
+ # frames; the warning will be issued from the currently executing
+ # line of code in that stack frame. A stacklevel of 1 is the
+ # 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)
+ # 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()
+ # 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
+ # is supported, this can invoke a signal handler written in
+ # Python. In all cases, the default effect for SIGINT is to raise
+ # the KeyboardInterrupt exception. If an exception is raised the
+ # error indicator is set and the function returns 1; otherwise the
+ # function returns 0. The error indicator may or may not be
+ # cleared if it was previously set.
+
+ void PyErr_SetInterrupt()
+ # This function simulates the effect of a SIGINT signal arriving
+ # -- the next time PyErr_CheckSignals() is called,
+ # KeyboardInterrupt will be raised. It may be called without
+ # holding the interpreter lock.
+
+ PyObject* PyErr_NewException(char *name, object base, object dict)
+ # Return value: New reference.
+ # This utility function creates and returns a new exception
+ # object. The name argument must be the name of the new exception,
+ # a C string of the form module.class. The base and dict arguments
+ # are normally NULL. This creates a class object derived from
+ # Exception (accessible in C as PyExc_Exception).
+
+ void PyErr_WriteUnraisable(object obj)
+ # This utility function prints a warning message to sys.stderr
+ # when an exception has been set but it is impossible for the
+ # interpreter to actually raise the exception. It is used, for
+ # example, when an exception occurs in an __del__() method.
+ #
+ # The function is called with a single argument obj that
+ # identifies the context in which the unraisable exception
+ # occurred. The repr of obj will be printed in the warning
+ # message.
+
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+
+ ############################################################################
+ # 7.2.3
+ ############################################################################
+ # PyFloatObject
+ # 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.
+
+ bint PyFloat_Check(object p)
+ # Return true if its argument is a PyFloatObject or a subtype of
+ # PyFloatObject.
+
+ bint PyFloat_CheckExact(object p)
+ # Return true if its argument is a PyFloatObject, but not a
+ # subtype of PyFloatObject.
+
+ object PyFloat_FromString(object str, char **pend)
+ # Return value: New reference.
+ # Create a PyFloatObject object based on the string value in str,
+ # or NULL on failure. The pend argument is ignored. It remains
+ # only for backward compatibility.
+
+ object PyFloat_FromDouble(double v)
+ # Return value: New reference.
+ # 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.
+
+ double PyFloat_AS_DOUBLE(object pyfloat)
+ # Return a C double representation of the contents of pyfloat, but without error checking.
--- /dev/null
+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.
+ # PyTypeObject PyFunction_Type
+ # This is an instance of PyTypeObject and represents the Python
+ # function type. It is exposed to Python programmers as
+ # types.FunctionType.
+
+ bint PyFunction_Check(object o)
+ # Return true if o is a function object (has type
+ # PyFunction_Type). The parameter must not be NULL.
+
+ object PyFunction_New(object code, object globals)
+ # Return value: New reference.
+ # 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.
+
+ PyObject* PyFunction_GetCode(object op)
+ # Return value: Borrowed reference.
+ # Return the code object associated with the function object op.
+
+ PyObject* PyFunction_GetGlobals(object op)
+ # Return value: Borrowed reference.
+ # Return the globals dictionary associated with the function object op.
+
+ PyObject* PyFunction_GetModule(object op)
+ # 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)
+ # Return value: Borrowed reference.
+ # 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)
+ # 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.
+
+ PyObject* PyFunction_GetClosure(object op)
+ # Return value: Borrowed reference.
+ # 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)
+ # 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.
--- /dev/null
+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)
+ # Return true if obj is an instance.
+
+ object PyInstance_New(PyObject* 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
+ # object's constructor.
+
+ object PyInstance_NewRaw(object cls, object dict)
+ # Return value: New reference.
+ # Create a new instance of a specific class without calling its
+ # constructor. class is the class of new object. The dict
+ # parameter will be used as the object's __dict__; if NULL, a new
+ # dictionary will be created for the instance.
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+
+ ############################################################################
+ # Integer Objects
+ ############################################################################
+ # PyTypeObject PyInt_Type
+ # This instance of PyTypeObject represents the Python plain
+ # integer type. This is the same object as int and types.IntType.
+
+ bint PyInt_Check(object o)
+ # Return true if o is of type PyInt_Type or a subtype of
+ # PyInt_Type.
+
+ bint PyInt_CheckExact(object o)
+ # Return true if o is of type PyInt_Type, but not a subtype of
+ # PyInt_Type.
+
+ object PyInt_FromString(char *str, char **pend, int base)
+ # Return value: New reference.
+ # Return a new PyIntObject or PyLongObject based on the string
+ # value in str, which is interpreted according to the radix in
+ # base. If pend is non-NULL, *pend will point to the first
+ # character in str which follows the representation of the
+ # number. If base is 0, the radix will be determined based on the
+ # leading characters of str: if str starts with '0x' or '0X',
+ # radix 16 will be used; if str starts with '0', radix 8 will be
+ # used; otherwise radix 10 will be used. If base is not 0, it must
+ # be between 2 and 36, inclusive. Leading spaces are ignored. If
+ # there are no digits, ValueError will be raised. If the string
+ # represents a number too large to be contained within the
+ # machine's long int type and overflow warnings are being
+ # suppressed, a PyLongObject will be returned. If overflow
+ # warnings are not being suppressed, NULL will be returned in this
+ # case.
+
+ object PyInt_FromLong(long ival)
+ # Return value: New reference.
+ # Create a new integer object with a value of ival.
+ # The current implementation keeps an array of integer objects for
+ # all integers between -5 and 256, when you create an int in that
+ # range you actually just get back a reference to the existing
+ # object. So it should be possible to change the value of 1. I
+ # suspect the behaviour of Python in this case is undefined. :-)
+
+ object PyInt_FromSsize_t(Py_ssize_t ival)
+ # Return value: New reference.
+ # 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)
+ # 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
+ # PyErr_Occurred() to find out whether there was an error, or
+ # whether the value just happened to be -1.
+
+ long PyInt_AS_LONG(object io)
+ # Return the value of the object io. No error checking is performed.
+
+ unsigned long PyInt_AsUnsignedLongMask(object io)
+ # 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.
+
+ 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
+ # value as unsigned long long, without checking for overflow.
+
+ Py_ssize_t PyInt_AsSsize_t(object io)
+ # 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.
+
+ long PyInt_GetMax()
+ # Return the system's idea of the largest integer it can handle
+ # (LONG_MAX, as defined in the system header files).
--- /dev/null
+cdef extern from "Python.h":
+
+ ############################################################################
+ # 6.5 Iterator Protocol
+ ############################################################################
+ int PyIter_Check(object o)
+ # Return true if the object o supports the iterator protocol.
+
+ object PyIter_Next(object o)
+ # Return value: New reference.
+ # Return the next value from the iteration o. If the object is an
+ # iterator, this retrieves the next value from the iteration, and
+ # returns NULL with no exception set if there are no remaining
+ # items. If the object is not an iterator, TypeError is raised, or
+ # if there is an error in retrieving the item, returns NULL and
+ # passes along the exception.
+
+ # To write a loop which iterates over an iterator, the C code should look something like this:
+ # PyObject *iterator = PyObject_GetIter(obj);
+ # PyObject *item;
+ # if (iterator == NULL) {
+ # /* propagate error */
+ # }
+ # while (item = PyIter_Next(iterator)) {
+ # /* do something with item */
+ # ...
+ # /* release reference when done */
+ # Py_DECREF(item);
+ # }
+ # Py_DECREF(iterator);
+ # if (PyErr_Occurred()) {
+ # /* propagate error */
+ # }
+ # else {
+ # /* continue doing useful work */
+ # }
--- /dev/null
+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
+ # 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.
+
+ bint PyList_CheckExact(object p)
+ # 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.
+
+ 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)
+ # 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
+ # list is not supported. If pos is out of bounds, return NULL and
+ # set an IndexError exception.
+
+ PyObject* PyList_GET_ITEM(object list, Py_ssize_t i)
+ # Return value: Borrowed reference.
+ # Macro form of PyList_GetItem() without error checking.
+
+ int PyList_SetItem(object list, Py_ssize_t index, object item)
+ # 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
+ # the affected position.
+
+ void PyList_SET_ITEM(object list, Py_ssize_t i, object o)
+ # Macro form of PyList_SetItem() without error checking. This is
+ # normally only used to fill in new lists where there is no
+ # previous content. Note: This function ``steals'' a reference to
+ # item, and, unlike PyList_SetItem(), does not discard a reference
+ # 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)
+ # 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)
+ # 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).
+
+ object PyList_GetSlice(object list, Py_ssize_t low, Py_ssize_t high)
+ # Return value: New reference.
+ # Return a list of the objects in list containing the objects
+ # 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)
+ # 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)
+ # 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)
+ # Reverse the items of list in place. Return 0 on success, -1 on
+ # failure. This is the equivalent of "list.reverse()".
+
+ object PyList_AsTuple(object list)
+ # Return value: New reference.
+ # Return a new tuple object containing the contents of list;
+ # equivalent to "tuple(list)".
+
+
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+ ctypedef long PY_LONG_LONG
+
+ ############################################################################
+ # 7.2.3 Long Integer Objects
+ ############################################################################
+ # PyLongObject
+ # 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.
+
+ bint PyLong_Check(object p)
+ # Return true if its argument is a PyLongObject or a subtype of PyLongObject.
+
+ bint PyLong_CheckExact(object p)
+ # Return true if its argument is a PyLongObject, but not a subtype of PyLongObject.
+
+ object PyLong_FromLong(long v)
+ # Return value: New reference.
+ # Return a new PyLongObject object from v, or NULL on failure.
+
+ object PyLong_FromUnsignedLong(unsigned long v)
+ # Return value: New reference.
+ # Return a new PyLongObject object from a C unsigned long, or NULL on failure.
+
+ object PyLong_FromLongLong(PY_LONG_LONG v)
+ # 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)
+ # Return value: New reference.
+ # Return a new PyLongObject object from a C unsigned long long, or NULL on failure.
+
+ object PyLong_FromDouble(double v)
+ # Return value: New reference.
+ # Return a new PyLongObject object from the integer part of v, or NULL on failure.
+
+ object PyLong_FromString(char *str, char **pend, int base)
+ # Return value: New reference.
+ # Return a new PyLongObject based on the string value in str,
+ # which is interpreted according to the radix in base. If pend is
+ # non-NULL, *pend will point to the first character in str which
+ # follows the representation of the number. If base is 0, the
+ # radix will be determined based on the leading characters of str:
+ # if str starts with '0x' or '0X', radix 16 will be used; if str
+ # starts with '0', radix 8 will be used; otherwise radix 10 will
+ # be used. If base is not 0, it must be between 2 and 36,
+ # 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)
+ # 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
+ # the Unicode string, length gives the number of characters, and
+ # base is the radix for the conversion. The radix must be in the
+ # range [2, 36]; if it is out of range, ValueError will be
+ # raised.
+
+ object PyLong_FromVoidPtr(void *p)
+ # Return value: New reference.
+ # Create a Python integer or long integer from the pointer p. The
+ # pointer value can be retrieved from the resulting value using
+ # PyLong_AsVoidPtr(). If the integer is larger than LONG_MAX, a
+ # positive long integer is returned.
+
+ long PyLong_AsLong(object pylong)
+ # 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)
+ # 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)
+ # Return a C long long from a Python long integer. If pylong
+ # cannot be represented as a long long, an OverflowError will be
+ # raised.
+
+ PY_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
+ # 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)
+ # Return a C unsigned long from a Python long integer, without
+ # checking for overflow.
+
+ PY_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)
+ # 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.
+
+ void* PyLong_AsVoidPtr(object pylong)
+ # 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
+ # for values created with PyLong_FromVoidPtr(). For values outside
+ # 0..LONG_MAX, both signed and unsigned integers are acccepted.
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+
+ ############################################################################
+ # 6.4 Mapping Protocol
+ ############################################################################
+
+ bint PyMapping_Check(object o)
+ # Return 1 if the object provides mapping protocol, and 0
+ # otherwise. This function always succeeds.
+
+ Py_ssize_t PyMapping_Length(object o)
+ # 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)
+ # 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)
+ # Remove the mapping for object key from the object o. Return -1
+ # on failure. This is equivalent to the Python statement "del
+ # o[key]".
+
+ bint PyMapping_HasKeyString(object o, char *key)
+ # On success, return 1 if the mapping object has the key key and 0
+ # otherwise. This is equivalent to the Python expression
+ # "o.has_key(key)". This function always succeeds.
+
+ bint PyMapping_HasKey(object o, object key)
+ # Return 1 if the mapping object has the key key and 0
+ # otherwise. This is equivalent to the Python expression
+ # "o.has_key(key)". This function always succeeds.
+
+ object PyMapping_Keys(object o)
+ # Return value: New reference.
+ # On success, return a list of the keys in object o. On failure,
+ # return NULL. This is equivalent to the Python expression
+ # "o.keys()".
+
+ object PyMapping_Values(object o)
+ # Return value: New reference.
+ # On success, return a list of the values in object o. On failure,
+ # return NULL. This is equivalent to the Python expression
+ # "o.values()".
+
+ object PyMapping_Items(object o)
+ # Return value: New reference.
+ # On success, return a list of the items in object o, where each
+ # item is a tuple containing a key-value pair. On failure, return
+ # NULL. This is equivalent to the Python expression "o.items()".
+
+ object PyMapping_GetItemString(object o, char *key)
+ # Return value: New reference.
+ # Return element of o corresponding to the object key or NULL on
+ # failure. This is the equivalent of the Python expression
+ # "o[key]".
+
+ int PyMapping_SetItemString(object o, char *key, object v)
+ # 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".
+
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef unsigned long size_t
+
+ #####################################################################
+ # 9.2 Memory Interface
+ #####################################################################
+ # You are definitely *supposed* to use these: "In most situations,
+ # however, it is recommended to allocate memory from the Python
+ # heap specifically because the latter is under control of the
+ # Python memory manager. For example, this is required when the
+ # interpreter is extended with new object types written in
+ # C. Another reason for using the Python heap is the desire to
+ # inform the Python memory manager about the memory needs of the
+ # extension module. Even when the requested memory is used
+ # exclusively for internal, highly-specific purposes, delegating
+ # all memory requests to the Python memory manager causes the
+ # interpreter to have a more accurate image of its memory
+ # footprint as a whole. Consequently, under certain circumstances,
+ # the Python memory manager may or may not trigger appropriate
+ # actions, like garbage collection, memory compaction or other
+ # preventive procedures. Note that by using the C library
+ # allocator as shown in the previous example, the allocated memory
+ # for the I/O buffer escapes completely the Python memory
+ # manager."
+
+ # The following function sets, modeled after the ANSI C standard,
+ # but specifying behavior when requesting zero bytes, are
+ # available for allocating and releasing memory from the Python
+ # heap:
+
+ void* PyMem_Malloc(size_t n)
+ # Allocates n bytes and returns a pointer of type void* to the
+ # allocated memory, or NULL if the request fails. Requesting zero
+ # bytes returns a distinct non-NULL pointer if possible, as if
+ # PyMem_Malloc(1) had been called instead. The memory will not
+ # have been initialized in any way.
+
+ void* PyMem_Realloc(void *p, size_t n)
+ # Resizes the memory block pointed to by p to n bytes. The
+ # contents will be unchanged to the minimum of the old and the new
+ # sizes. If p is NULL, the call is equivalent to PyMem_Malloc(n);
+ # else if n is equal to zero, the memory block is resized but is
+ # not freed, and the returned pointer is non-NULL. Unless p is
+ # NULL, it must have been returned by a previous call to
+ # PyMem_Malloc() or PyMem_Realloc().
+
+ void PyMem_Free(void *p)
+ # Frees the memory block pointed to by p, which must have been
+ # returned by a previous call to PyMem_Malloc() or
+ # PyMem_Realloc(). Otherwise, or if PyMem_Free(p) has been called
+ # before, undefined behavior occurs. If p is NULL, no operation is
+ # performed.
+
+ # The following type-oriented macros are provided for
+ # convenience. Note that TYPE refers to any C type.
+
+ # TYPE* PyMem_New(TYPE, size_t n)
+ # Same as PyMem_Malloc(), but allocates (n * sizeof(TYPE)) bytes
+ # of memory. Returns a pointer cast to TYPE*. The memory will not
+ # have been initialized in any way.
+
+ # TYPE* PyMem_Resize(void *p, TYPE, size_t n)
+ # Same as PyMem_Realloc(), but the memory block is resized to (n *
+ # sizeof(TYPE)) bytes. Returns a pointer cast to TYPE*.
+
+ void PyMem_Del(void *p)
+ # Same as PyMem_Free().
+
+ # In addition, the following macro sets are provided for calling
+ # the Python memory allocator directly, without involving the C
+ # API functions listed above. However, note that their use does
+ # not preserve binary compatibility across Python versions and is
+ # therefore deprecated in extension modules.
+
+ # PyMem_MALLOC(), PyMem_REALLOC(), PyMem_FREE().
+ # PyMem_NEW(), PyMem_RESIZE(), PyMem_DEL().
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+ ############################################################################
+ # 7.5.4 Method Objects
+ ############################################################################
+
+ # There are some useful functions that are useful for working with method objects.
+ # PyTypeObject PyMethod_Type
+ # This instance of PyTypeObject represents the Python method type. This is exposed to Python programs as types.MethodType.
+
+ bint PyMethod_Check(object o)
+ # Return true if o is a method object (has type
+ # PyMethod_Type). The parameter must not be NULL.
+
+ object PyMethod_New(object func, object self, object cls)
+ # Return value: New reference.
+ # Return a new method object, with func being any callable object;
+ # this is the function that will be called when the method is
+ # called. If this method should be bound to an instance, self
+ # should be the instance and class should be the class of self,
+ # otherwise self should be NULL and class should be the class
+ # which provides the unbound method..
+
+ PyObject* PyMethod_Class(object meth)
+ # 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
+ # the instance.
+
+ PyObject* PyMethod_GET_CLASS(object meth)
+ # Return value: Borrowed reference.
+ # Macro version of PyMethod_Class() which avoids error checking.
+
+ PyObject* PyMethod_Function(object meth)
+ # Return value: Borrowed reference.
+ # Return the function object associated with the method meth.
+
+ PyObject* PyMethod_GET_FUNCTION(object meth)
+ # Return value: Borrowed reference.
+ # Macro version of PyMethod_Function() which avoids error checking.
+
+ PyObject* PyMethod_Self(object meth)
+ # Return value: Borrowed reference.
+ # Return the instance associated with the method meth if it is bound, otherwise return NULL.
+
+ PyObject* PyMethod_GET_SELF(object meth)
+ # Return value: Borrowed reference.
+ # Macro version of PyMethod_Self() which avoids error checking.
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+ ctypedef struct _inittab
+
+ #####################################################################
+ # 5.3 Importing Modules
+ #####################################################################
+ object PyImport_ImportModule(char *name)
+ # Return value: New reference.
+ # This is a simplified interface to PyImport_ImportModuleEx()
+ # below, leaving the globals and locals arguments set to
+ # NULL. When the name argument contains a dot (when it specifies a
+ # submodule of a package), the fromlist argument is set to the
+ # list ['*'] so that the return value is the named module rather
+ # than the top-level package containing it as would otherwise be
+ # the case. (Unfortunately, this has an additional side effect
+ # when name in fact specifies a subpackage instead of a submodule:
+ # the submodules specified in the package's __all__ variable are
+ # loaded.) Return a new reference to the imported module, or NULL
+ # with an exception set on failure.
+
+ object PyImport_ImportModuleEx(char *name, object globals, object locals, object fromlist)
+ # Return value: New reference.
+
+ # 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. Changed in version 2.4:
+ # failing imports remove incomplete module objects.
+
+ object PyImport_Import(object name)
+ # Return value: New reference.
+ # This is a higher-level interface that calls the current ``import
+ # hook function''. It invokes the __import__() function from the
+ # __builtins__ of the current globals. This means that the import
+ # is done using whatever import hooks are installed in the current
+ # environment, e.g. by rexec or ihooks.
+
+ object PyImport_ReloadModule(object m)
+ # Return value: New reference.
+ # Reload a module. This is best described by referring to the
+ # built-in Python function reload(), as the standard reload()
+ # function calls this function directly. Return a new reference to
+ # the reloaded module, or NULL with an exception set on failure
+ # (the module still exists in this case).
+
+ PyObject* PyImport_AddModule(char *name)
+ # 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
+ # modules dictionary if there's one there, and if not, create a
+ # new one and insert it in the modules dictionary. Return NULL
+ # with an exception set on failure. Note: This function does not
+ # load or import the module; if the module wasn't already loaded,
+ # you will get an empty module object. Use PyImport_ImportModule()
+ # or one of its variants to import a module. Package structures
+ # implied by a dotted name for name are not created if not already
+ # present.
+
+ object PyImport_ExecCodeModule(char *name, object co)
+ # Return value: New reference.
+ # Given a module name (possibly of the form package.module) and a
+ # code object read from a Python bytecode file or obtained from
+ # the built-in function compile(), load the module. Return a new
+ # reference to the module object, or NULL with an exception set if
+ # an error occurred. Name is removed from sys.modules in error
+ # cases, and even if name was already in sys.modules on entry to
+ # PyImport_ExecCodeModule(). Leaving incompletely initialized
+ # modules in sys.modules is dangerous, as imports of such modules
+ # have no way to know that the module object is an unknown (and
+ # probably damaged with respect to the module author's intents)
+ # state.
+ # This function will reload the module if it was already
+ # imported. See PyImport_ReloadModule() for the intended way to
+ # reload a module.
+ # If name points to a dotted name of the form package.module, any
+ # package structures not already created will still not be
+ # created.
+
+
+ long PyImport_GetMagicNumber()
+ # 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.
+
+ PyObject* PyImport_GetModuleDict()
+ # Return value: Borrowed reference.
+ # Return the dictionary used for the module administration
+ # (a.k.a. sys.modules). Note that this is a per-interpreter
+ # variable.
+
+
+ int PyImport_ImportFrozenModule(char *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.)
+
+
+ int PyImport_ExtendInittab(_inittab *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().
+
+ #####################################################################
+ # 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_Check(object p)
+ # Return true if p is a module object, or a subtype of a module
+ # object.
+
+ 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)
+ # 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
+ # filled in; the caller is responsible for providing a __file__
+ # attribute.
+
+ PyObject* PyModule_GetDict(object module)
+ # 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
+ # object. This function never fails. It is recommended extensions
+ # use other PyModule_*() and PyObject_*() functions rather than
+ # directly manipulate a module's __dict__.
+
+ char* PyModule_GetName(object module)
+ # 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)
+ # 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)
+ # 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)
+ # 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)
+ # 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
+ # error, 0 on success.
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+ ctypedef void PyTypeObject
+ ctypedef struct FILE
+
+
+ #####################################################################
+ # 6.2 Number Protocol
+ #####################################################################
+
+ bint PyNumber_Check(object o)
+ # Returns 1 if the object o provides numeric protocols, and false
+ # otherwise. This function always succeeds.
+
+ object PyNumber_Add(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of adding o1 and o2, or NULL on failure. This
+ # is the equivalent of the Python expression "o1 + o2".
+
+ object PyNumber_Subtract(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of subtracting o2 from o1, or NULL on
+ # failure. This is the equivalent of the Python expression "o1 -
+ # o2".
+
+ object PyNumber_Multiply(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of multiplying o1 and o2, or NULL on
+ # failure. This is the equivalent of the Python expression "o1 *
+ # o2".
+
+ object PyNumber_Divide(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of dividing o1 by o2, or NULL on
+ # failure. This is the equivalent of the Python expression "o1 /
+ # o2".
+
+ object PyNumber_FloorDivide(object o1, object o2)
+ # Return value: New reference.
+ # Return the floor of o1 divided by o2, or NULL on failure. This
+ # is equivalent to the ``classic'' division of integers.
+
+ object PyNumber_TrueDivide(object o1, object o2)
+ # Return value: New reference.
+ # Return a reasonable approximation for the mathematical value of
+ # o1 divided by o2, or NULL on failure. The return value is
+ # ``approximate'' because binary floating point numbers are
+ # approximate; it is not possible to represent all real numbers in
+ # base two. This function can return a floating point value when
+ # passed two integers.
+
+ object PyNumber_Remainder(object o1, object o2)
+ # Return value: New reference.
+ # Returns the remainder of dividing o1 by o2, or NULL on
+ # failure. This is the equivalent of the Python expression "o1 %
+ # o2".
+
+ object PyNumber_Divmod(object o1, object o2)
+ # Return value: New reference.
+ # See the built-in function divmod(). Returns NULL on
+ # failure. This is the equivalent of the Python expression
+ # "divmod(o1, o2)".
+
+ object PyNumber_Power(object o1, object o2, object o3)
+ # Return value: New reference.
+ # See the built-in function pow(). Returns NULL on failure. This
+ # is the equivalent of the Python expression "pow(o1, o2, o3)",
+ # where o3 is optional. If o3 is to be ignored, pass Py_None in
+ # its place (passing NULL for o3 would cause an illegal memory
+ # access).
+
+ object PyNumber_Negative(object o)
+ # Return value: New reference.
+ # Returns the negation of o on success, or NULL on failure. This
+ # is the equivalent of the Python expression "-o".
+
+ object PyNumber_Positive(object o)
+ # Return value: New reference.
+ # Returns o on success, or NULL on failure. This is the equivalent
+ # of the Python expression "+o".
+
+ object PyNumber_Absolute(object o)
+ # Return value: New reference.
+ # Returns the absolute value of o, or NULL on failure. This is the
+ # equivalent of the Python expression "abs(o)".
+
+ object PyNumber_Invert(object o)
+ # Return value: New reference.
+ # Returns the bitwise negation of o on success, or NULL on
+ # failure. This is the equivalent of the Python expression "~o".
+
+ object PyNumber_Lshift(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of left shifting o1 by o2 on success, or NULL
+ # on failure. This is the equivalent of the Python expression "o1
+ # << o2".
+
+ object PyNumber_Rshift(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of right shifting o1 by o2 on success, or
+ # NULL on failure. This is the equivalent of the Python expression
+ # "o1 >> o2".
+
+ object PyNumber_And(object o1, object o2)
+ # Return value: New reference.
+ # Returns the ``bitwise and'' of o1 and o2 on success and NULL on
+ # failure. This is the equivalent of the Python expression "o1 &
+ # o2".
+
+ object PyNumber_Xor(object o1, object o2)
+ # Return value: New reference.
+ # Returns the ``bitwise exclusive or'' of o1 by o2 on success, or
+ # NULL on failure. This is the equivalent of the Python expression
+ # "o1 ^ o2".
+
+ object PyNumber_Or(object o1, object o2)
+ # Return value: New reference.
+ # Returns the ``bitwise or'' of o1 and o2 on success, or NULL on failure. This is the equivalent of the Python expression "o1 | o2".
+
+ object PyNumber_InPlaceAdd(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of adding o1 and o2, or NULL on failure. The
+ # operation is done in-place when o1 supports it. This is the
+ # equivalent of the Python statement "o1 += o2".
+
+ object PyNumber_InPlaceSubtract(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of subtracting o2 from o1, or NULL on
+ # failure. The operation is done in-place when o1 supports
+ # it. This is the equivalent of the Python statement "o1 -= o2".
+
+ object PyNumber_InPlaceMultiply(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of multiplying o1 and o2, or NULL on
+ # failure. The operation is done in-place when o1 supports
+ # it. This is the equivalent of the Python statement "o1 *= o2".
+
+ object PyNumber_InPlaceDivide(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of dividing o1 by o2, or NULL on failure. The
+ # operation is done in-place when o1 supports it. This is the
+ # equivalent of the Python statement "o1 /= o2".
+
+ object PyNumber_InPlaceFloorDivide(object o1, object o2)
+ # Return value: New reference.
+ # Returns the mathematical floor of dividing o1 by o2, or NULL on
+ # failure. The operation is done in-place when o1 supports
+ # it. This is the equivalent of the Python statement "o1 //=
+ # o2".
+
+ object PyNumber_InPlaceTrueDivide(object o1, object o2)
+ # Return value: New reference.
+ # Return a reasonable approximation for the mathematical value of
+ # o1 divided by o2, or NULL on failure. The return value is
+ # ``approximate'' because binary floating point numbers are
+ # approximate; it is not possible to represent all real numbers in
+ # base two. This function can return a floating point value when
+ # passed two integers. The operation is done in-place when o1
+ # supports it.
+
+ object PyNumber_InPlaceRemainder(object o1, object o2)
+ # Return value: New reference.
+ # Returns the remainder of dividing o1 by o2, or NULL on
+ # failure. The operation is done in-place when o1 supports
+ # it. This is the equivalent of the Python statement "o1 %= o2".
+
+ object PyNumber_InPlacePower(object o1, object o2, object o3)
+ # Return value: New reference.
+ # See the built-in function pow(). Returns NULL on failure. The
+ # operation is done in-place when o1 supports it. This is the
+ # equivalent of the Python statement "o1 **= o2" when o3 is
+ # Py_None, or an in-place variant of "pow(o1, o2, o3)"
+ # otherwise. If o3 is to be ignored, pass Py_None in its place
+ # (passing NULL for o3 would cause an illegal memory access).
+
+ object PyNumber_InPlaceLshift(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of left shifting o1 by o2 on success, or NULL
+ # on failure. The operation is done in-place when o1 supports
+ # it. This is the equivalent of the Python statement "o1 <<= o2".
+
+ object PyNumber_InPlaceRshift(object o1, object o2)
+ # Return value: New reference.
+ # Returns the result of right shifting o1 by o2 on success, or
+ # NULL on failure. The operation is done in-place when o1 supports
+ # it. This is the equivalent of the Python statement "o1 >>= o2".
+
+ object PyNumber_InPlaceAnd(object o1, object o2)
+ # Return value: New reference.
+ # Returns the ``bitwise and'' of o1 and o2 on success and NULL on
+ # failure. The operation is done in-place when o1 supports
+ # it. This is the equivalent of the Python statement "o1 &= o2".
+
+ object PyNumber_InPlaceXor(object o1, object o2)
+ # Return value: New reference.
+ # Returns the ``bitwise exclusive or'' of o1 by o2 on success, or
+ # NULL on failure. The operation is done in-place when o1 supports
+ # it. This is the equivalent of the Python statement "o1 ^= o2".
+
+ object PyNumber_InPlaceOr(object o1, object o2)
+ # Return value: New reference.
+ # Returns the ``bitwise or'' of o1 and o2 on success, or NULL on
+ # 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)
+ # 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
+ # (success). If the objects can be converted to a common numeric
+ # type, replace *p1 and *p2 by their converted value (with 'new'
+ # reference counts), and return 0. If no conversion is possible,
+ # or if some other error occurs, return -1 (failure) and don't
+ # increment the reference counts. The call PyNumber_Coerce(&o1,
+ # &o2) is equivalent to the Python statement "o1, o2 = coerce(o1,
+ # o2)".
+
+ object PyNumber_Int(object o)
+ # Return value: New reference.
+ # Returns the o converted to an integer object on success, or NULL
+ # on failure. If the argument is outside the integer range a long
+ # object will be returned instead. This is the equivalent of the
+ # Python expression "int(o)".
+
+ object PyNumber_Long(object o)
+ # Return value: New reference.
+ # Returns the o converted to a long integer object on success, or
+ # NULL on failure. This is the equivalent of the Python expression
+ # "long(o)".
+
+ object PyNumber_Float(object o)
+ # Return value: New reference.
+ # Returns the o converted to a float object on success, or NULL on
+ # failure. This is the equivalent of the Python expression
+ # "float(o)".
+
+ object PyNumber_Index(object o)
+ # 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)
+ # 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
+ # raise an OverflowError, then the exc argument is the type of
+ # exception that will be raised (usually IndexError or
+ # OverflowError). If exc is NULL, then the exception is cleared
+ # and the value is clipped to PY_SSIZE_T_MIN for a negative
+ # 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).
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+ ctypedef void PyTypeObject
+ ctypedef struct FILE
+
+ #####################################################################
+ # 6.1 Object Protocol
+ #####################################################################
+ int PyObject_Print(object o, FILE *fp, int flags)
+ # 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()
+ # of the object is written instead of the repr().
+
+ bint PyObject_HasAttrString(object o, char *attr_name)
+ # Returns 1 if o has the attribute attr_name, and 0
+ # otherwise. This is equivalent to the Python expression
+ # "hasattr(o, attr_name)". This function always succeeds.
+
+ object PyObject_GetAttrString(object o, char *attr_name)
+ # Return value: New reference. Retrieve an attribute named
+ # attr_name from object o. Returns the attribute value on success,
+ # or NULL on failure. This is the equivalent of the Python
+ # expression "o.attr_name".
+
+ bint PyObject_HasAttr(object o, object attr_name)
+ # Returns 1 if o has the attribute attr_name, and 0
+ # otherwise. This is equivalent to the Python expression
+ # "hasattr(o, attr_name)". This function always succeeds.
+
+ object PyObject_GetAttr(object o, object attr_name)
+ # Return value: New reference. Retrieve an attribute named
+ # attr_name from object o. Returns the attribute value on success,
+ # 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)
+ # 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)
+ # 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)
+ # 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)
+ # Delete attribute named attr_name, for object o. Returns -1 on
+ # failure. This is the equivalent of the Python statement "del
+ # o.attr_name".
+
+ object PyObject_RichCompare(object o1, object o2, int opid)
+ # Return value: New reference.
+ # 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 >=
+ # respectively. This is the equivalent of the Python expression
+ # "o1 op o2", where op is the operator corresponding to
+ # opid. Returns the value of the comparison on success, or NULL on
+ # failure.
+
+ int PyObject_RichCompareBool(object o1, object o2, int opid)
+ # 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 >=
+ # respectively. Returns -1 on error, 0 if the result is false, 1
+ # 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)
+ # 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)
+ # 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
+ # returned is undefined; use PyErr_Occurred() to detect an
+ # error. This is equivalent to the Python expression "cmp(o1,
+ # o2)".
+
+ object PyObject_Repr(object o)
+ # Return value: New reference.
+ # Compute a string representation of object o. Returns the string
+ # representation on success, NULL on failure. This is the
+ # equivalent of the Python expression "repr(o)". Called by the
+ # repr() built-in function and by reverse quotes.
+
+ object PyObject_Str(object o)
+ # Return value: New reference.
+ # Compute a string representation of object o. Returns the string
+ # representation on success, NULL on failure. This is the
+ # equivalent of the Python expression "str(o)". Called by the
+ # str() built-in function and by the print statement.
+
+ object PyObject_Unicode(object o)
+ # Return value: New reference.
+ # Compute a Unicode string representation of object o. Returns the
+ # Unicode string representation on success, NULL on failure. This
+ # is the equivalent of the Python expression "unicode(o)". Called
+ # by the unicode() built-in function.
+
+ bint PyObject_IsInstance(object inst, object cls)
+ # 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,
+ # PyObject_IsInstance() returns 1 if inst is of type cls. If cls
+ # is a tuple, the check will be done against every entry in
+ # cls. The result will be 1 when at least one of the checks
+ # returns 1, otherwise it will be 0. If inst is not a class
+ # instance and cls is neither a type object, nor a class object,
+ # nor a tuple, inst must have a __class__ attribute -- the class
+ # relationship of the value of that attribute with cls will be
+ # used to determine the result of this function.
+
+ # Subclass determination is done in a fairly straightforward way,
+ # but includes a wrinkle that implementors of extensions to the
+ # class system may want to be aware of. If A and B are class
+ # objects, B is a subclass of A if it inherits from A either
+ # directly or indirectly. If either is not a class object, a more
+ # general mechanism is used to determine the class relationship of
+ # the two objects. When testing if B is a subclass of A, if A is
+ # B, PyObject_IsSubclass() returns true. If A and B are different
+ # objects, B's __bases__ attribute is searched in a depth-first
+ # fashion for A -- the presence of the __bases__ attribute is
+ # considered sufficient for this determination.
+
+ bint PyObject_IsSubclass(object derived, object cls)
+ # 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
+ # entry in cls. The result will be 1 when at least one of the
+ # checks returns 1, otherwise it will be 0. If either derived or
+ # cls is not an actual class object (or tuple), this function uses
+ # the generic algorithm described above. New in version
+ # 2.1. Changed in version 2.3: Older versions of Python did not
+ # support a tuple as the second argument.
+
+ bint PyCallable_Check(object o)
+ # Determine if the object o is callable. Return 1 if the object is
+ # callable and 0 otherwise. This function always succeeds.
+
+ object PyObject_Call(object callable_object, object args, object kw)
+ # Return value: New reference.
+ # Call a callable Python object callable_object, with arguments
+ # given by the tuple args, and named arguments given by the
+ # dictionary kw. If no named arguments are needed, kw may be
+ # NULL. args must not be NULL, use an empty tuple if no arguments
+ # are needed. Returns the result of the call on success, or NULL
+ # on failure. This is the equivalent of the Python expression
+ # "apply(callable_object, args, kw)" or "callable_object(*args,
+ # **kw)".
+
+ object PyObject_CallObject(object callable_object, object args)
+ # Return value: New reference.
+ # Call a callable Python object callable_object, with arguments
+ # given by the tuple args. If no arguments are needed, then args
+ # may be NULL. Returns the result of the call on success, or NULL
+ # on failure. This is the equivalent of the Python expression
+ # "apply(callable_object, args)" or "callable_object(*args)".
+
+ object PyObject_CallFunction(object callable, char *format, ...)
+ # Return value: New reference.
+ # Call a callable Python object callable, with a variable number
+ # of C arguments. The C arguments are described using a
+ # Py_BuildValue() style format string. The format may be NULL,
+ # indicating that no arguments are provided. Returns the result of
+ # the call on success, or NULL on failure. This is the equivalent
+ # of the Python expression "apply(callable, args)" or
+ # "callable(*args)". Note that if you only pass object args,
+ # PyObject_CallFunctionObjArgs is a faster alternative.
+
+ object PyObject_CallMethod(object o, char *method, char *format, ...)
+ # Return value: New reference.
+ # Call the method named method of object o with a variable number
+ # of C arguments. The C arguments are described by a
+ # Py_BuildValue() format string that should produce a tuple. The
+ # format may be NULL, indicating that no arguments are
+ # provided. Returns the result of the call on success, or NULL on
+ # failure. This is the equivalent of the Python expression
+ # "o.method(args)". Note that if you only pass object args,
+ # PyObject_CallMethodObjArgs is a faster alternative.
+
+ #object PyObject_CallFunctionObjArgs(object callable, ..., NULL)
+ object PyObject_CallFunctionObjArgs(object callable, ...)
+ # Return value: New reference.
+ # Call a callable Python object callable, with a variable number
+ # of PyObject* arguments. The arguments are provided as a variable
+ # number of parameters followed by NULL. Returns the result of the
+ # call on success, or NULL on failure.
+
+ #PyObject* PyObject_CallMethodObjArgs(object o, object name, ..., NULL)
+ object PyObject_CallMethodObjArgs(object o, object name, ...)
+ # Return value: New reference.
+ # Calls a method of the object o, where the name of the method is
+ # given as a Python string object in name. It is called with a
+ # variable number of PyObject* arguments. The arguments are
+ # provided as a variable number of parameters followed by
+ # NULL. Returns the result of the call on success, or NULL on
+ # failure.
+
+ long PyObject_Hash(object o)
+ # 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)
+ # 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)
+ # 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.
+
+ object PyObject_Type(object o)
+ # Return value: New reference.
+ # When o is non-NULL, returns a type object corresponding to the
+ # object type of object o. On failure, raises SystemError and
+ # returns NULL. This is equivalent to the Python expression
+ # type(o). This function increments the reference count of the
+ # return value. There's really no reason to use this function
+ # instead of the common expression o->ob_type, which returns a
+ # pointer of type PyTypeObject*, except when the incremented
+ # reference count is needed.
+
+ bint PyObject_TypeCheck(object o, object type) # object o, PyTypeObject *type)
+ # 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)
+ # 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
+ # the Python expression "len(o)".
+
+ object PyObject_GetItem(object o, object key)
+ # Return value: New reference.
+ # Return element of o corresponding to the object key or NULL on
+ # failure. This is the equivalent of the Python expression
+ # "o[key]".
+
+ int PyObject_SetItem(object o, object key, object v)
+ # 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)
+ # 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)
+ # 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
+ # return an integer or long integer, which is returned as the file
+ # descriptor value. Returns -1 on failure.
+
+ object PyObject_Dir(object o)
+ # Return value: New reference.
+ # This is equivalent to the Python expression "dir(o)", returning
+ # a (possibly empty) list of strings appropriate for the object
+ # argument, or NULL if there was an error. If the argument is
+ # NULL, this is like the Python "dir()", returning the names of
+ # the current locals; in this case, if no execution frame is
+ # active then NULL is returned but PyErr_Occurred() will return
+ # false.
+
+ object PyObject_GetIter(object o)
+ # Return value: New reference.
+ # This is equivalent to the Python expression "iter(o)". It
+ # returns a new iterator for the object argument, or the object
+ # itself if the object is already an iterator. Raises TypeError
+ # and returns NULL if the object cannot be iterated.
+
--- /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, ...)
+
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+ ctypedef void PyTypeObject
+ ctypedef struct FILE
+
+
+ #####################################################################
+ # 3. Reference Counts
+ #####################################################################
+ # The macros in this section are used for managing reference counts of Python objects.
+ void Py_INCREF(object o)
+ # Increment the reference count for object o. The object must not
+ # be NULL; if you aren't sure that it isn't NULL, use
+ # Py_XINCREF().
+
+ void Py_XINCREF(object o)
+ # Increment the reference count for object o. The object may be NULL, in which case the macro has no effect.
+
+ void Py_DECREF(object o)
+ # Decrement the reference count for object o. The object must not
+ # be NULL; if you aren't sure that it isn't NULL, use
+ # Py_XDECREF(). If the reference count reaches zero, the object's
+ # type's deallocation function (which must not be NULL) is
+ # invoked.
+
+ # Warning: The deallocation function can cause arbitrary Python
+ # code to be invoked (e.g. when a class instance with a __del__()
+ # method is deallocated). While exceptions in such code are not
+ # propagated, the executed code has free access to all Python
+ # global variables. This means that any object that is reachable
+ # from a global variable should be in a consistent state before
+ # Py_DECREF() is invoked. For example, code to delete an object
+ # from a list should copy a reference to the deleted object in a
+ # temporary variable, update the list data structure, and then
+ # call Py_DECREF() for the temporary variable.
+
+ void Py_XDECREF(object o)
+ # Decrement the reference count for object o. The object may be
+ # NULL, in which case the macro has no effect; otherwise the
+ # effect is the same as for Py_DECREF(), and the same warning
+ # applies.
+
+ void Py_CLEAR(object o)
+ # Decrement the reference count for object o. The object may be
+ # NULL, in which case the macro has no effect; otherwise the
+ # effect is the same as for Py_DECREF(), except that the argument
+ # is also set to NULL. The warning for Py_DECREF() does not apply
+ # with respect to the object passed because the macro carefully
+ # uses a temporary variable and sets the argument to NULL before
+ # decrementing its reference count.
+ # It is a good idea to use this macro whenever decrementing the
+ # value of a variable that might be traversed during garbage
+ # collection.
+
--- /dev/null
+ ############################################################################
+ # 6.3 Sequence Protocol
+ ############################################################################
+
+cdef extern from "Python.h":
+ ctypedef void PyObject
+
+
+ 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)
+ # 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)
+ # Alternate name for PySequence_Size().
+
+ object PySequence_Concat(object o1, object o2)
+ # Return value: New reference.
+ # Return the concatenation of o1 and o2 on success, and NULL on
+ # failure. This is the equivalent of the Python expression "o1 +
+ # o2".
+
+ object PySequence_Repeat(object o, Py_ssize_t count)
+ # Return value: New reference.
+ # Return the result of repeating sequence object o count times, or
+ # NULL on failure. This is the equivalent of the Python expression
+ # "o * count".
+
+ object PySequence_InPlaceConcat(object o1, object o2)
+ # Return value: New reference.
+ # Return the concatenation of o1 and o2 on success, and NULL on
+ # failure. The operation is done in-place when o1 supports
+ # it. This is the equivalent of the Python expression "o1 += o2".
+
+ object PySequence_InPlaceRepeat(object o, Py_ssize_t count)
+ # Return value: New reference.
+ # Return the result of repeating sequence object o count times, or
+ # NULL on failure. The operation is done in-place when o supports
+ # it. This is the equivalent of the Python expression "o *=
+ # count".
+
+ object PySequence_GetItem(object o, Py_ssize_t i)
+ # Return value: New reference.
+ # Return the ith element of o, or NULL on failure. This is the
+ # equivalent of the Python expression "o[i]".
+
+ object PySequence_GetSlice(object o, Py_ssize_t i1, Py_ssize_t i2)
+ # Return value: New reference.
+ # Return the slice of sequence object o between i1 and i2, or NULL
+ # on failure. This is the equivalent of the Python expression
+ # "o[i1:i2]".
+
+ int PySequence_SetItem(object o, Py_ssize_t i, object v)
+ # 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)
+ # 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)
+ # 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)
+ # 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)
+ # 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)
+ # 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)
+ # Return the first index i for which o[i] == value. On error,
+ # return -1. This is equivalent to the Python expression
+ # "o.index(value)".
+
+ object PySequence_List(object o)
+ # Return value: New reference.
+ # Return a list object with the same contents as the arbitrary
+ # sequence o. The returned list is guaranteed to be new.
+
+ object PySequence_Tuple(object o)
+ # Return value: New reference.
+ # Return a tuple object with the same contents as the arbitrary
+ # sequence o or NULL on failure. If o is a tuple, a new reference
+ # will be returned, otherwise a tuple will be constructed with the
+ # appropriate contents. This is equivalent to the Python
+ # expression "tuple(o)".
+
+ object PySequence_Fast(object o, char *m)
+ # Return value: New reference.
+ # Returns the sequence o as a tuple, unless it is already a tuple
+ # or list, in which case o is returned. Use
+ # PySequence_Fast_GET_ITEM() to access the members of the
+ # result. Returns NULL on failure. If the object is not a
+ # sequence, raises TypeError with m as the message text.
+
+ PyObject* PySequence_Fast_GET_ITEM(object o, Py_ssize_t i)
+ # Return value: Borrowed reference.
+ # Return the ith element of o, assuming that o was returned by
+ # PySequence_Fast(), o is not NULL, and that i is within bounds.
+
+ PyObject** PySequence_Fast_ITEMS(object o)
+ # Return the underlying array of PyObject pointers. Assumes that o
+ # was returned by PySequence_Fast() and o is not NULL.
+
+ object PySequence_ITEM(object o, Py_ssize_t i)
+ # Return value: New reference.
+ # Return the ith element of o or NULL on failure. Macro form of
+ # PySequence_GetItem() but without checking that
+ # PySequence_Check(o) is true and without adjustment for negative
+ # indices.
+
+ int PySequence_Fast_GET_SIZE(object o)
+ # Returns the length of o, assuming that o was returned by
+ # PySequence_Fast() and that o is not NULL. The size can also be
+ # gotten by calling PySequence_Size() on o, but
+ # PySequence_Fast_GET_SIZE() is faster because it can assume o is
+ # a list or tuple.
+
+
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+
+ ############################################################################
+ # 7.5.14 Set Objects
+ ############################################################################
+
+ # This section details the public API for set and frozenset
+ # objects. Any functionality not listed below is best accessed
+ # using the either the abstract object protocol (including
+ # PyObject_CallMethod(), PyObject_RichCompareBool(),
+ # PyObject_Hash(), PyObject_Repr(), PyObject_IsTrue(),
+ # PyObject_Print(), and PyObject_GetIter()) or the abstract number
+ # protocol (including PyNumber_Add(), PyNumber_Subtract(),
+ # PyNumber_Or(), PyNumber_Xor(), PyNumber_InPlaceAdd(),
+ # PyNumber_InPlaceSubtract(), PyNumber_InPlaceOr(), and
+ # PyNumber_InPlaceXor()).
+
+ # PySetObject
+ # This subtype of PyObject is used to hold the internal data for
+ # both set and frozenset objects. It is like a PyDictObject in
+ # that it is a fixed size for small sets (much like tuple storage)
+ # and will point to a separate, variable sized block of memory for
+ # medium and large sized sets (much like list storage). None of
+ # the fields of this structure should be considered public and are
+ # subject to change. All access should be done through the
+ # documented API rather than by manipulating the values in the
+ # structure.
+
+ # PyTypeObject PySet_Type
+ # This is an instance of PyTypeObject representing the Python set type.
+
+ # PyTypeObject PyFrozenSet_Type
+ # This is an instance of PyTypeObject representing the Python frozenset type.
+
+ # The following type check macros work on pointers to any Python
+ # object. Likewise, the constructor functions work with any
+ # iterable Python object.
+
+ bint PyAnySet_Check(object p)
+ # Return true if p is a set object, a frozenset object, or an
+ # instance of a subtype.
+
+ bint PyAnySet_CheckExact(object p)
+ # Return true if p is a set object or a frozenset object but not
+ # an instance of a subtype.
+
+ bint PyFrozenSet_CheckExact(object p)
+ # Return true if p is a frozenset object but not an instance of a subtype.
+
+ 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
+ # set. Return the new set on success or NULL on failure. Raise
+ # TypeError if iterable is not actually iterable. The constructor
+ # is also useful for copying a set (c=set(s)).
+
+ 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
+ # 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)
+ # 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)
+ # 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
+ # temporary frozensets. Raise a TypeError if the key is
+ # 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)
+ # 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)
+ # 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
+ # the Python discard() method, this function does not
+ # automatically convert unhashable sets into temporary
+ # frozensets. Raise PyExc_SystemError if set is an not an instance
+ # of set or its subtype.
+
+ 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
+ # KeyError if the set is empty. Raise a SystemError if set is an
+ # not an instance of set or its subtype.
+
+ int PySet_Clear(object set)
+ # Empty an existing set of all elements.
+
--- /dev/null
+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
+ # This subtype of PyObject represents a Python string object.
+ # PyTypeObject PyString_Type
+ # This instance of PyTypeObject represents the Python string type;
+ # it is the same object as str and types.StringType in the Python
+ # layer.
+
+ bint PyString_Check(object o)
+ # Return true if the object o is a string object or an instance of
+ # a subtype of the string type.
+
+ bint PyString_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 PyString_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 PyString_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 PyString_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 PyString_FromFormatV(char *format, va_list vargs)
+ # Return value: New reference.
+ # Identical to PyString_FromFormat() except that it takes exactly two arguments.
+
+ Py_ssize_t PyString_Size(object string)
+ # Return the length of the string in string object string.
+
+ Py_ssize_t PyString_GET_SIZE(object string)
+ # Macro form of PyString_Size() but without error checking.
+
+ char* PyString_AsString(object string)
+ # 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 PyString_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,
+ # PyString_AsString() returns NULL and raises TypeError.
+
+ char* PyString_AS_STRING(object string)
+ # Macro form of PyString_AsString() but without error
+ # checking. Only string objects are supported; no Unicode objects
+ # should be passed.
+
+ int PyString_AsStringAndSize(object obj, char **buffer, Py_ssize_t *length)
+ # 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 PyString_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,
+ # PyString_AsStringAndSize() returns -1 and raises TypeError.
+
+ void PyString_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 PyString_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 _PyString_Resize(PyObject **string, Py_ssize_t newsize)
+ # 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 PyString_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 PyString_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 PyString_InternFromString(char *v)
+ # Return value: New reference.
+ # A combination of PyString_FromString() and
+ # PyString_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 PyString_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 PyString_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 PyString_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 PyString_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.
+
+
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+
+ ############################################################################
+ # Tuples
+ ############################################################################
+
+ bint PyTuple_Check(object p)
+ # Return true if p is a tuple object or an instance of a subtype
+ # of the tuple type.
+
+ bint PyTuple_CheckExact(object p)
+ # Return true if p is a tuple object, but not an instance of a subtype of the tuple type.
+
+ object PyTuple_New(Py_ssize_t len)
+ # Return value: New reference.
+ # Return a new tuple object of size len, or NULL on failure.
+
+ object PyTuple_Pack(Py_ssize_t n, ...)
+ # Return value: New reference.
+ # Return a new tuple object of size n, or NULL on failure. The
+ # tuple values are initialized to the subsequent n C arguments
+ # pointing to Python objects. "PyTuple_Pack(2, a, b)" is
+ # equivalent to "Py_BuildValue("(OO)", a, b)".
+
+ int PyTuple_Size(object p)
+ # Take a pointer to a tuple object, and return the size of that tuple.
+
+ int PyTuple_GET_SIZE(object p)
+ # 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)
+ # 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
+ # exception.
+
+ PyObject* PyTuple_GET_ITEM(object p, Py_ssize_t pos)
+ # Return value: Borrowed reference.
+ # Like PyTuple_GetItem(), but does no checking of its arguments.
+
+ object PyTuple_GetSlice(object p, Py_ssize_t low, Py_ssize_t high)
+ # Return value: New reference.
+ # Take a slice of the tuple pointed to by p from low to high and return it as a new tuple.
+
+ int PyTuple_SetItem(object p, Py_ssize_t pos, object o)
+ # Insert a reference to object o at position pos of the tuple
+ # pointed to by p. Return 0 on success. Note: This function
+ # ``steals'' a reference to o.
+
+ void PyTuple_SET_ITEM(object p, Py_ssize_t pos, object o)
+ # Like PyTuple_SetItem(), but does no error checking, and should
+ # 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)
+ # 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
+ # object. Do not use this if the tuple may already be known to
+ # some other part of the code. The tuple will always grow or
+ # shrink at the end. Think of this as destroying the old tuple and
+ # creating a new one, only more efficiently. Returns 0 on
+ # success. Client code should never assume that the resulting
+ # value of *p will be the same as before calling this function. If
+ # the object referenced by *p is replaced, the original *p is
+ # destroyed. On failure, returns -1 and sets *p to NULL, and
+ # raises MemoryError or SystemError.
+
--- /dev/null
+cdef extern from "Python.h":
+ ctypedef void PyObject
+ ctypedef void PyTypeObject
+ # The C structure of the objects used to describe built-in types.
+
+ ############################################################################
+ # 7.1.1 Type Objects
+ ############################################################################
+
+ # PyObject* PyType_Type
+ # This is the type object for type objects; it is the same object
+ # as type and types.TypeType in the Python layer.
+
+ bint PyType_Check(object o)
+ # Return true if the object o is a type object, including
+ # instances of types derived from the standard type object. Return
+ # false in all other cases.
+
+ bint PyType_CheckExact(object o)
+ # Return true if the object o is a type object, but not a subtype
+ # of the standard type object. Return false in all other
+ # cases.
+
+ bint PyType_HasFeature(object o, int feature)
+ # Return true if the type object o sets the feature feature. Type
+ # features are denoted by single bit flags.
+
+ bint PyType_IS_GC(object o)
+ # Return true if the type object includes support for the cycle
+ # detector; this tests the type flag Py_TPFLAGS_HAVE_GC.
+
+ bint PyType_IsSubtype(object a, object b)
+ # Return true if a is a subtype of b.
+
+ object PyType_GenericAlloc(object type, Py_ssize_t nitems)
+ # Return value: New reference.
+
+ object PyType_GenericNew(object type, object args, object kwds)
+ # Return value: New reference.
+
+ bint PyType_Ready(object type)
+ # 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
+ # class. Return 0 on success, or return -1 and sets an exception
+ # on error.
--- /dev/null
+cdef extern from "stdio.h":
+ ctypedef struct FILE
+ int printf(char *format, ...)
+ int fprintf(FILE *stream, char *format, ...)
+ int sprintf(char *str, char *format, ...)
+ FILE *fopen(char *path, char *mode)
+ int fclose(FILE *strea)
+ cdef FILE *stdout
+ int scanf(char *format, ...)
--- /dev/null
+
+cdef extern from "stdlib.h":
+ ctypedef unsigned long size_t
+ void free(void *ptr)
+ void *malloc(size_t size)
+ void *realloc(void *ptr, size_t size)
+ size_t strlen(char *s)
+ char *strcpy(char *dest, char *src)
projects / cython.git / commitdiff