Skip to content

C
cython
Commit 44f4ce29 authored by Craig Citro's avatar Craig Citro
Browse files
Options

merge

parents cec8145d 8a0ab027
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 4112 additions and 3922 deletions
Cython/Compiler/Buffer.py
View file @ 44f4ce29
......@@ -368,8 +368,12 @@ def put_buffer_lookup_code(entry, index_signeds, index_cnames, directives, pos,
code.putln("%s = %d;" % (tmp_cname, dim))
code.put("} else ")
# check bounds in positive direction
if signed != 0:
cast = ""
else:
cast = "(size_t)"
code.putln("if (%s) %s = %d;" % (
code.unlikely("%s >= %s" % (cname, shape.cname)),
code.unlikely("%s >= %s%s" % (cname, cast, shape.cname)),
tmp_cname, dim))
code.globalstate.use_utility_code(raise_indexerror_code)
code.putln("if (%s) {" % code.unlikely("%s != -1" % tmp_cname))
......
Cython/Compiler/DebugFlags.py
View file @ 44f4ce29
......@@ -10,7 +10,7 @@ debug_temp_code_comments = 0
debug_trace_code_generation = 0
# Do not replace exceptions with user-friendly error messages
debug_no_exception_intercept = 1
debug_no_exception_intercept = 0
# Print a message each time a new stage in the pipeline is entered
debug_verbose_pipeline = 0
Cython/Compiler/ModuleNode.py
View file @ 44f4ce29
......@@ -426,6 +426,11 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
code.globalstate["end"].putln("#endif /* Py_PYTHON_H */")
code.put("""
#include <stddef.h> /* For offsetof */
#ifndef offsetof
#define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
#endif
#ifndef PY_LONG_LONG
#define PY_LONG_LONG LONG_LONG
#endif
......@@ -903,7 +908,6 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
self.generate_descr_set_function(scope, code)
self.generate_property_accessors(scope, code)
self.generate_method_table(scope, code)
self.generate_member_table(scope, code)
self.generate_getset_table(scope, code)
self.generate_typeobj_definition(full_module_name, entry, code)
......@@ -1529,34 +1533,6 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
code.putln(
"};")
def generate_member_table(self, env, code):
#print "ModuleNode.generate_member_table: scope =", env ###
if env.public_attr_entries:
code.putln("")
code.putln(
"static struct PyMemberDef %s[] = {" %
env.member_table_cname)
type = env.parent_type
if type.typedef_flag:
objstruct = type.objstruct_cname
else:
objstruct = "struct %s" % type.objstruct_cname
for entry in env.public_attr_entries:
type_code = entry.type.pymemberdef_typecode
if entry.visibility == 'readonly':
flags = "READONLY"
else:
flags = "0"
code.putln('{(char *)"%s", %s, %s, %s, 0},' % (
entry.name,
type_code,
"offsetof(%s, %s)" % (objstruct, entry.cname),
flags))
code.putln(
"{0, 0, 0, 0, 0}")
code.putln(
"};")
def generate_getset_table(self, env, code):
if env.property_entries:
code.putln("")
......
Cython/Compiler/Nodes.py
View file @ 44f4ce29
......@@ -891,13 +891,13 @@ class CVarDefNode(StatNode):
# declarators [CDeclaratorNode]
# in_pxd boolean
# api boolean
# need_properties [entry]
# properties [entry]
# decorators [cython.locals(...)] or None
# directive_locals { string : NameNode } locals defined by cython.locals(...)
child_attrs = ["base_type", "declarators"]
need_properties = ()
properties = ()
decorators = None
directive_locals = {}
......@@ -912,15 +912,12 @@ class CVarDefNode(StatNode):
# so do conversion ourself rather than rely on the CPython mechanism (through
# a property; made in AnalyseDeclarationsTransform).
if (dest_scope.is_c_class_scope
and self.visibility == 'public'
and base_type.is_pyobject
and (base_type.is_builtin_type or base_type.is_extension_type)):
self.need_properties = []
and self.visibility in ('public', 'readonly')):
self.properties = []
need_property = True
visibility = 'private'
else:
need_property = False
visibility = self.visibility
visibility = self.visibility
for declarator in self.declarators:
name_declarator, type = declarator.analyse(base_type, env)
......@@ -951,8 +948,7 @@ class CVarDefNode(StatNode):
entry = dest_scope.declare_var(name, type, declarator.pos,
cname = cname, visibility = visibility, is_cdef = 1)
if need_property:
self.need_properties.append(entry)
entry.needs_property = 1
self.properties.append(entry)
class CStructOrUnionDefNode(StatNode):
......
Cython/Compiler/ParseTreeTransforms.py
View file @ 44f4ce29
......@@ -952,6 +952,11 @@ property NAME:
def __set__(self, value):
ATTR = value
""", level='c_class')
basic_property_ro = TreeFragment(u"""
property NAME:
def __get__(self):
return ATTR
""", level='c_class')
def __call__(self, root):
self.env_stack = [root.scope]
......@@ -1037,12 +1042,9 @@ property NAME:
# to ensure all CNameDeclaratorNodes are visited.
self.visitchildren(node)
if node.need_properties:
# cdef public attributes may need type testing on
# assignment, so we create a property accesss
# mechanism for them.
if node.properties:
stats = []
for entry in node.need_properties:
for entry in node.properties:
property = self.create_Property(entry)
property.analyse_declarations(node.dest_scope)
self.visit(property)
......@@ -1052,13 +1054,34 @@ property NAME:
return None
def create_Property(self, entry):
template = self.basic_property
if entry.visibility == 'public':
template = self.basic_property
elif entry.visibility == 'readonly':
template = self.basic_property_ro
property = template.substitute({
u"ATTR": AttributeNode(pos=entry.pos,
obj=NameNode(pos=entry.pos, name="self"),
attribute=entry.name),
}, pos=entry.pos).stats[0]
property.name = entry.name
# ---------------------------------------
# XXX This should go to AutoDocTransforms
# ---------------------------------------
if self.current_directives['embedsignature']:
attr_name = entry.name
type_name = entry.type.declaration_code("", for_display=1)
default_value = ''
if not entry.type.is_pyobject:
type_name = "'%s'" % type_name
elif entry.type.is_extension_type:
type_name = entry.type.module_name + '.' + type_name
if entry.init is not None:
default_value = ' = ' + entry.init
elif entry.init_to_none:
default_value = ' = ' + repr(None)
docstring = attr_name + ': ' + type_name + default_value
property.doc = EncodedString(docstring)
# ---------------------------------------
return property
class AnalyseExpressionsTransform(CythonTransform):
......
Cython/Compiler/Parsing.py
View file @ 44f4ce29
......@@ -13,10 +13,10 @@ import sys
try:
from __builtin__ import set
except ImportError:
except (ImportError, AttributeError):
try:
from builtins import set
except ImportError:
except (ImportError, AttributeError):
from sets import Set as set
from Cython.Compiler.Scanning import PyrexScanner, FileSourceDescriptor
......
Cython/Compiler/PyrexTypes.py
View file @ 44f4ce29
......@@ -56,7 +56,6 @@ class PyrexType(BaseType):
# is_buffer boolean Is buffer access type
# has_attributes boolean Has C dot-selectable attributes
# default_value string Initial value
# pymemberdef_typecode string Type code for PyMemberDef struct
#
# declaration_code(entity_code,
# for_display = 0, dll_linkage = None, pyrex = 0)
......@@ -109,7 +108,6 @@ class PyrexType(BaseType):
is_buffer = 0
has_attributes = 0
default_value = ""
pymemberdef_typecode = None
def resolve(self):
# If a typedef, returns the base type.
......@@ -198,18 +196,6 @@ class CTypedefType(BaseType):
self.typedef_cname = cname
self.typedef_base_type = base_type
self.typedef_is_external = is_external
# Make typecodes in external typedefs use typesize-neutral macros
if is_external:
typecode = None
if base_type.is_int:
if base_type.signed == 0:
typecode = "__Pyx_T_UNSIGNED_INT"
else:
typecode = "__Pyx_T_SIGNED_INT"
elif base_type.is_float and not rank_to_type_name[base_type.rank] == "long double":
typecode = "__Pyx_T_FLOATING"
if typecode:
self.pymemberdef_typecode = "%s(%s)" % (typecode, cname)
def resolve(self):
return self.typedef_base_type.resolve()
......@@ -349,7 +335,6 @@ class PyObjectType(PyrexType):
name = "object"
is_pyobject = 1
default_value = "0"
pymemberdef_typecode = "T_OBJECT"
buffer_defaults = None
is_extern = False
is_subclassed = False
......@@ -626,10 +611,9 @@ class CNumericType(CType):
sign_words = ("unsigned ", "", "signed ")
def __init__(self, rank, signed = 1, pymemberdef_typecode = None):
def __init__(self, rank, signed = 1):
self.rank = rank
self.signed = signed
self.pymemberdef_typecode = pymemberdef_typecode
def sign_and_name(self):
s = self.sign_words[self.signed]
......@@ -795,8 +779,8 @@ class CIntType(CNumericType):
from_py_function = "__Pyx_PyInt_AsInt"
exception_value = -1
def __init__(self, rank, signed, pymemberdef_typecode = None, is_returncode = 0):
CNumericType.__init__(self, rank, signed, pymemberdef_typecode)
def __init__(self, rank, signed, is_returncode = 0):
CNumericType.__init__(self, rank, signed)
self.is_returncode = is_returncode
if self.from_py_function == "__Pyx_PyInt_AsInt":
self.from_py_function = self.get_type_conversion()
......@@ -895,8 +879,8 @@ class CFloatType(CNumericType):
exception_value = -1
def __init__(self, rank, pymemberdef_typecode = None, math_h_modifier = ''):
CNumericType.__init__(self, rank, 1, pymemberdef_typecode)
def __init__(self, rank, math_h_modifier = ''):
CNumericType.__init__(self, rank, 1)
self.math_h_modifier = math_h_modifier
def assignable_from_resolved_type(self, src_type):
......@@ -1996,7 +1980,6 @@ class CStringType(object):
class CUTF8CharArrayType(CStringType, CArrayType):
# C 'char []' type.
pymemberdef_typecode = "T_STRING_INPLACE"
is_unicode = 1
to_py_function = "PyUnicode_DecodeUTF8"
......@@ -2008,8 +1991,6 @@ class CUTF8CharArrayType(CStringType, CArrayType):
class CCharArrayType(CStringType, CArrayType):
# C 'char []' type.
pymemberdef_typecode = "T_STRING_INPLACE"
def __init__(self, size):
CArrayType.__init__(self, c_char_type, size)
......@@ -2017,8 +1998,6 @@ class CCharArrayType(CStringType, CArrayType):
class CCharPtrType(CStringType, CPtrType):
# C 'char *' type.
pymemberdef_typecode = "T_STRING"
def __init__(self):
CPtrType.__init__(self, c_char_type)
......@@ -2026,8 +2005,6 @@ class CCharPtrType(CStringType, CPtrType):
class CUCharPtrType(CStringType, CPtrType):
# C 'unsigned char *' type.
pymemberdef_typecode = "T_STRING"
to_py_function = "__Pyx_PyBytes_FromUString"
from_py_function = "__Pyx_PyBytes_AsUString"
......@@ -2093,30 +2070,30 @@ c_void_type = CVoidType()
c_void_ptr_type = CPtrType(c_void_type)
c_void_ptr_ptr_type = CPtrType(c_void_ptr_type)
c_uchar_type = CIntType(0, 0, "T_UBYTE")
c_ushort_type = CIntType(1, 0, "T_USHORT")
c_uint_type = CUIntType(2, 0, "T_UINT")
c_ulong_type = CULongType(3, 0, "T_ULONG")
c_ulonglong_type = CULongLongType(6, 0, "T_ULONGLONG")
c_char_type = CIntType(0, 1, "T_CHAR")
c_short_type = CIntType(1, 1, "T_SHORT")
c_int_type = CIntType(2, 1, "T_INT")
c_long_type = CLongType(3, 1, "T_LONG")
c_longlong_type = CLongLongType(6, 1, "T_LONGLONG")
c_bint_type = CBIntType(2, 1, "T_INT")
c_schar_type = CIntType(0, 2, "T_CHAR")
c_sshort_type = CIntType(1, 2, "T_SHORT")
c_sint_type = CIntType(2, 2, "T_INT")
c_slong_type = CLongType(3, 2, "T_LONG")
c_slonglong_type = CLongLongType(6, 2, "T_LONGLONG")
c_py_ssize_t_type = CPySSizeTType(4, 2, "T_PYSSIZET")
c_size_t_type = CSizeTType(5, 0, "T_SIZET")
c_float_type = CFloatType(7, "T_FLOAT", math_h_modifier='f')
c_double_type = CFloatType(8, "T_DOUBLE")
c_uchar_type = CIntType(0, 0)
c_ushort_type = CIntType(1, 0)
c_uint_type = CUIntType(2, 0)
c_ulong_type = CULongType(3, 0)
c_ulonglong_type = CULongLongType(6, 0)
c_char_type = CIntType(0, 1)
c_short_type = CIntType(1, 1)
c_int_type = CIntType(2, 1)
c_long_type = CLongType(3, 1)
c_longlong_type = CLongLongType(6, 1)
c_bint_type = CBIntType(2, 1)
c_schar_type = CIntType(0, 2)
c_sshort_type = CIntType(1, 2)
c_sint_type = CIntType(2, 2)
c_slong_type = CLongType(3, 2)
c_slonglong_type = CLongLongType(6, 2)
c_py_ssize_t_type = CPySSizeTType(4, 2)
c_size_t_type = CSizeTType(5, 0)
c_float_type = CFloatType(7, math_h_modifier='f')
c_double_type = CFloatType(8)
c_longdouble_type = CFloatType(9, math_h_modifier='l')
c_double_complex_type = CComplexType(c_double_type)
......@@ -2131,7 +2108,7 @@ c_int_ptr_type = CPtrType(c_int_type)
c_py_ssize_t_ptr_type = CPtrType(c_py_ssize_t_type)
c_size_t_ptr_type = CPtrType(c_size_t_type)
c_returncode_type = CIntType(2, 1, "T_INT", is_returncode = 1)
c_returncode_type = CIntType(2, 1, is_returncode = 1)
c_anon_enum_type = CAnonEnumType(-1, 1)
......@@ -2500,68 +2477,6 @@ type_conversion_predeclarations = """
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x);
#if !defined(T_PYSSIZET)
#if PY_VERSION_HEX < 0x02050000
#define T_PYSSIZET T_INT
#elif !defined(T_LONGLONG)
#define T_PYSSIZET \\
((sizeof(Py_ssize_t) == sizeof(int)) ? T_INT : \\
((sizeof(Py_ssize_t) == sizeof(long)) ? T_LONG : -1))
#else
#define T_PYSSIZET \\
((sizeof(Py_ssize_t) == sizeof(int)) ? T_INT : \\
((sizeof(Py_ssize_t) == sizeof(long)) ? T_LONG : \\
((sizeof(Py_ssize_t) == sizeof(PY_LONG_LONG)) ? T_LONGLONG : -1)))
#endif
#endif
#if !defined(T_ULONGLONG)
#define __Pyx_T_UNSIGNED_INT(x) \\
((sizeof(x) == sizeof(unsigned char)) ? T_UBYTE : \\
((sizeof(x) == sizeof(unsigned short)) ? T_USHORT : \\
((sizeof(x) == sizeof(unsigned int)) ? T_UINT : \\
((sizeof(x) == sizeof(unsigned long)) ? T_ULONG : -1))))
#else
#define __Pyx_T_UNSIGNED_INT(x) \\
((sizeof(x) == sizeof(unsigned char)) ? T_UBYTE : \\
((sizeof(x) == sizeof(unsigned short)) ? T_USHORT : \\
((sizeof(x) == sizeof(unsigned int)) ? T_UINT : \\
((sizeof(x) == sizeof(unsigned long)) ? T_ULONG : \\
((sizeof(x) == sizeof(unsigned PY_LONG_LONG)) ? T_ULONGLONG : -1)))))
#endif
#if !defined(T_LONGLONG)
#define __Pyx_T_SIGNED_INT(x) \\
((sizeof(x) == sizeof(char)) ? T_BYTE : \\
((sizeof(x) == sizeof(short)) ? T_SHORT : \\
((sizeof(x) == sizeof(int)) ? T_INT : \\
((sizeof(x) == sizeof(long)) ? T_LONG : -1))))
#else
#define __Pyx_T_SIGNED_INT(x) \\
((sizeof(x) == sizeof(char)) ? T_BYTE : \\
((sizeof(x) == sizeof(short)) ? T_SHORT : \\
((sizeof(x) == sizeof(int)) ? T_INT : \\
((sizeof(x) == sizeof(long)) ? T_LONG : \\
((sizeof(x) == sizeof(PY_LONG_LONG)) ? T_LONGLONG : -1)))))
#endif
#define __Pyx_T_FLOATING(x) \\
((sizeof(x) == sizeof(float)) ? T_FLOAT : \\
((sizeof(x) == sizeof(double)) ? T_DOUBLE : -1))
#if !defined(T_SIZET)
#if !defined(T_ULONGLONG)
#define T_SIZET \\
((sizeof(size_t) == sizeof(unsigned int)) ? T_UINT : \\
((sizeof(size_t) == sizeof(unsigned long)) ? T_ULONG : -1))
#else
#define T_SIZET \\
((sizeof(size_t) == sizeof(unsigned int)) ? T_UINT : \\
((sizeof(size_t) == sizeof(unsigned long)) ? T_ULONG : \\
((sizeof(size_t) == sizeof(unsigned PY_LONG_LONG)) ? T_ULONGLONG : -1)))
#endif
#endif
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
static CYTHON_INLINE size_t __Pyx_PyInt_AsSize_t(PyObject*);
......
Cython/Compiler/Symtab.py
View file @ 44f4ce29
......@@ -789,7 +789,7 @@ class ModuleScope(Scope):
self.doc_cname = Naming.moddoc_cname
self.utility_code_list = []
self.module_entries = {}
self.python_include_files = ["Python.h", "structmember.h"]
self.python_include_files = ["Python.h"]
self.include_files = []
self.type_names = dict(outer_scope.type_names)
self.pxd_file_loaded = 0
......@@ -1319,10 +1319,8 @@ class CClassScope(ClassScope):
# #typeobj_cname string or None
# #objstruct_cname string
# method_table_cname string
# member_table_cname string
# getset_table_cname string
# has_pyobject_attrs boolean Any PyObject attributes?
# public_attr_entries boolean public/readonly attrs
# property_entries [Entry]
# defined boolean Defined in .pxd file
# implemented boolean Defined in .pyx file
......@@ -1334,10 +1332,8 @@ class CClassScope(ClassScope):
ClassScope.__init__(self, name, outer_scope)
if visibility != 'extern':
self.method_table_cname = outer_scope.mangle(Naming.methtab_prefix, name)
self.member_table_cname = outer_scope.mangle(Naming.memtab_prefix, name)
self.getset_table_cname = outer_scope.mangle(Naming.gstab_prefix, name)
self.has_pyobject_attrs = 0
self.public_attr_entries = []
self.property_entries = []
self.inherited_var_entries = []
self.defined = 0
......@@ -1378,16 +1374,14 @@ class CClassScope(ClassScope):
error(pos,
"Attribute of extension type cannot be declared %s" % visibility)
if visibility in ('public', 'readonly'):
if type.pymemberdef_typecode:
self.public_attr_entries.append(entry)
if name == "__weakref__":
error(pos, "Special attribute __weakref__ cannot be exposed to Python")
else:
error(pos,
"C attribute of type '%s' cannot be accessed from Python" % type)
if visibility == 'public' and type.is_extension_type:
error(pos,
"Non-generic Python attribute cannot be exposed for writing from Python")
if name == "__weakref__":
error(pos, "Special attribute __weakref__ cannot be exposed to Python")
if not type.is_pyobject:
if (not type.create_to_py_utility_code(self) or
(visibility=='public' and not
type.create_from_py_utility_code(self))):
error(pos,
"C attribute of type '%s' cannot be accessed from Python" % type)
return entry
else:
if type is unspecified_type:
......
Cython/Compiler/TypeSlots.py
View file @ 44f4ce29
......@@ -370,10 +370,7 @@ class MemberTableSlot(SlotDescriptor):
# Slot descriptor for the table of Python-accessible attributes.
def slot_code(self, scope):
if scope.public_attr_entries:
return scope.member_table_cname
else:
return "0"
return "0"
class GetSetSlot(SlotDescriptor):
......
Cython/Includes/cpython/__init__.pxd 0 → 100644
View file @ 44f4ce29
#####################################################################
#
# These are the Cython pxd files for (most of) the Python/C API.
#
# REFERENCE COUNTING:
#
# JUST TO SCARE YOU:
# If you are going to use any of the Python/C API in your Cython
# 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 Cython 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 Cython 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. Cython will use the latest
# declaration.
#
# Cython 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.
#
#################################################################
from cpython.version cimport *
from cpython.ref cimport *
from cpython.exc cimport *
from cpython.module cimport *
from cpython.mem cimport *
from cpython.tuple cimport *
from cpython.list cimport *
from cpython.object cimport *
from cpython.sequence cimport *
from cpython.mapping cimport *
from cpython.iterator cimport *
from cpython.type cimport *
from cpython.number cimport *
from cpython.int cimport *
from cpython.bool cimport *
from cpython.long cimport *
from cpython.float cimport *
from cpython.complex cimport *
from cpython.string cimport *
from cpython.unicode cimport *
from cpython.dict cimport *
from cpython.instance cimport *
from cpython.function cimport *
from cpython.method cimport *
from cpython.weakref cimport *
from cpython.getargs cimport *
# Python <= 2.x
from cpython.cobject cimport *
from cpython.oldbuffer cimport *
# Python >= 2.4
from cpython.set cimport *
# Python >= 2.6
from cpython.buffer cimport *
from cpython.bytes cimport *
# Python >= 3.0
from cpython.pycapsule cimport *
Cython/Includes/cpython/bool.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "Python.h":
############################################################################
# 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.
Cython/Includes/cpython/buffer.pxd 0 → 100644
View file @ 44f4ce29
# Please see the Python header files (object.h/abstract.h) for docs
cdef extern from "Python.h":
cdef enum:
PyBUF_SIMPLE,
PyBUF_WRITABLE,
PyBUF_WRITEABLE, # backwards compatability
PyBUF_FORMAT,
PyBUF_ND,
PyBUF_STRIDES,
PyBUF_C_CONTIGUOUS,
PyBUF_F_CONTIGUOUS,
PyBUF_ANY_CONTIGUOUS,
PyBUF_INDIRECT,
PyBUF_CONTIG,
PyBUF_CONTIG_RO,
PyBUF_STRIDED,
PyBUF_STRIDED_RO,
PyBUF_RECORDS,
PyBUF_RECORDS_RO,
PyBUF_FULL,
PyBUF_FULL_RO,
PyBUF_READ,
PyBUF_WRITE,
PyBUF_SHADOW
bint PyObject_CheckBuffer(object obj)
# Return 1 if obj supports the buffer interface otherwise 0.
int PyObject_GetBuffer(object obj, Py_buffer *view, int flags) except -1
# Export obj into a Py_buffer, view. These arguments must never be
# NULL. The flags argument is a bit field indicating what kind of
# buffer the caller is prepared to deal with and therefore what
# kind of buffer the exporter is allowed to return. The buffer
# interface allows for complicated memory sharing possibilities,
# but some caller may not be able to handle all the complexity but
# may want to see if the exporter will let them take a simpler
# view to its memory.
# Some exporters may not be able to share memory in every possible
# way and may need to raise errors to signal to some consumers
# that something is just not possible. These errors should be a
# BufferError unless there is another error that is actually
# causing the problem. The exporter can use flags information to
# simplify how much of the Py_buffer structure is filled in with
# non-default values and/or raise an error if the object can’t
# support a simpler view of its memory.
# 0 is returned on success and -1 on error.
void PyBuffer_Release(object obj, object view)
# Release the buffer view over obj. This should be called when the
# buffer is no longer being used as it may free memory from it.
void* PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)
# ??
int PyBuffer_SizeFromFormat(char *) # actually const char
# Return the implied ~Py_buffer.itemsize from the struct-stype
# ~Py_buffer.format
int PyBuffer_ToContiguous(void *buf, Py_buffer *view, Py_ssize_t len, char fort)
# ??
int PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)
# ??
int PyObject_CopyToObject(object obj, void *buf, Py_ssize_t len, char fortran) except -1
# Copy len bytes of data pointed to by the contiguous chunk of
# memory pointed to by buf into the buffer exported by obj. The
# buffer must of course be writable. Return 0 on success and
# return -1 and raise an error on failure. If the object does not
# have a writable buffer, then an error is raised. If fortran is
# 'F', then if the object is multi-dimensional, then the data will
# be copied into the array in Fortran-style (first dimension
# varies the fastest). If fortran is 'C', then the data will be
# copied into the array in C-style (last dimension varies the
# fastest). If fortran is 'A', then it does not matter and the
# copy will be made in whatever way is more efficient.
int PyObject_CopyData(object dest, object src) except -1
# Copy the data from the src buffer to the buffer of destination
bint PyBuffer_IsContiguous(Py_buffer *view, char fort)
# Return 1 if the memory defined by the view is C-style (fortran
# is 'C') or Fortran-style (fortran is 'F') contiguous or either
# one (fortran is 'A'). Return 0 otherwise.
void PyBuffer_FillContiguousStrides(int ndims,
Py_ssize_t *shape,
Py_ssize_t *strides,
int itemsize,
char fort)
# Fill the strides array with byte-strides of a contiguous
# (Fortran-style if fort is 'F' or C-style otherwise) array of the
# given shape with the given number of bytes per element.
int PyBuffer_FillInfo(Py_buffer *view, void *buf,
Py_ssize_t len, int readonly,
int flags) except -1
# Fill in a buffer-info structure, view, correctly for an exporter
# that can only share a contiguous chunk of memory of “unsigned
# bytes” of the given length. Return 0 on success and -1 (with
# raising an error) on error.
object PyObject_Format(object obj, object format_spec)
# Takes an arbitrary object and returns the result of calling
# obj.__format__(format_spec).
Cython/Includes/cpython/bytes.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
cdef extern from "Python.h":
ctypedef struct va_list
############################################################################
# 7.3.1 String Objects
############################################################################
# These functions raise TypeError when expecting a string
# parameter and are called with a non-string parameter.
# PyStringObject
# This subtype of PyObject represents a Python bytes object.
# PyTypeObject PyBytes_Type
# This instance of PyTypeObject represents the Python bytes type;
# it is the same object as bytes and types.BytesType in the Python
# layer.
bint PyBytes_Check(object o)
# Return true if the object o is a string object or an instance of
# a subtype of the string type.
bint PyBytes_CheckExact(object o)
# Return true if the object o is a string object, but not an instance of a subtype of the string type.
object PyBytes_FromString(char *v)
# Return value: New reference.
# Return a new string object with the value v on success, and NULL
# on failure. The parameter v must not be NULL; it will not be
# checked.
object PyBytes_FromStringAndSize(char *v, Py_ssize_t len)
# Return value: New reference.
# Return a new string object with the value v and length len on
# success, and NULL on failure. If v is NULL, the contents of the
# string are uninitialized.
object PyBytes_FromFormat(char *format, ...)
# Return value: New reference.
# Take a C printf()-style format string and a variable number of
# arguments, calculate the size of the resulting Python string and
# return a string with the values formatted into it. The variable
# arguments must be C types and must correspond exactly to the
# format characters in the format string. The following format
# characters are allowed:
# Format Characters Type Comment
# %% n/a The literal % character.
# %c int A single character, represented as an C int.
# %d int Exactly equivalent to printf("%d").
# %u unsigned int Exactly equivalent to printf("%u").
# %ld long Exactly equivalent to printf("%ld").
# %lu unsigned long Exactly equivalent to printf("%lu").
# %zd Py_ssize_t Exactly equivalent to printf("%zd").
# %zu size_t Exactly equivalent to printf("%zu").
# %i int Exactly equivalent to printf("%i").
# %x int Exactly equivalent to printf("%x").
# %s char* A null-terminated C character array.
# %p void* The hex representation of a C pointer.
# Mostly equivalent to printf("%p") except that it is guaranteed to
# start with the literal 0x regardless of what the platform's printf
# yields.
# An unrecognized format character causes all the rest of the
# format string to be copied as-is to the result string, and any
# extra arguments discarded.
object PyBytes_FromFormatV(char *format, va_list vargs)
# Return value: New reference.
# Identical to PyBytes_FromFormat() except that it takes exactly two arguments.
Py_ssize_t PyBytes_Size(object string) except -1
# Return the length of the string in string object string.
Py_ssize_t PyBytes_GET_SIZE(object string)
# Macro form of PyBytes_Size() but without error checking.
char* PyBytes_AsString(object string) except NULL
# Return a NUL-terminated representation of the contents of
# string. The pointer refers to the internal buffer of string, not
# a copy. The data must not be modified in any way, unless the
# string was just created using PyBytes_FromStringAndSize(NULL,
# size). It must not be deallocated. If string is a Unicode
# object, this function computes the default encoding of string
# and operates on that. If string is not a string object at all,
# PyBytes_AsString() returns NULL and raises TypeError.
char* PyBytes_AS_STRING(object string)
# Macro form of PyBytes_AsString() but without error
# checking. Only string objects are supported; no Unicode objects
# should be passed.
int PyBytes_AsStringAndSize(object obj, char **buffer, Py_ssize_t *length) except -1
# Return a NULL-terminated representation of the contents of the
# object obj through the output variables buffer and length.
#
# The function accepts both string and Unicode objects as
# input. For Unicode objects it returns the default encoded
# version of the object. If length is NULL, the resulting buffer
# may not contain NUL characters; if it does, the function returns
# -1 and a TypeError is raised.
# The buffer refers to an internal string buffer of obj, not a
# copy. The data must not be modified in any way, unless the
# string was just created using PyBytes_FromStringAndSize(NULL,
# size). It must not be deallocated. If string is a Unicode
# object, this function computes the default encoding of string
# and operates on that. If string is not a string object at all,
# PyBytes_AsStringAndSize() returns -1 and raises TypeError.
void PyBytes_Concat(PyObject **string, object newpart)
# Create a new string object in *string containing the contents of
# newpart appended to string; the caller will own the new
# reference. The reference to the old value of string will be
# stolen. If the new string cannot be created, the old reference
# to string will still be discarded and the value of *string will
# be set to NULL; the appropriate exception will be set.
void PyBytes_ConcatAndDel(PyObject **string, object newpart)
# Create a new string object in *string containing the contents of
# newpart appended to string. This version decrements the
# reference count of newpart.
int _PyBytes_Resize(PyObject **string, Py_ssize_t newsize) except -1
# A way to resize a string object even though it is
# ``immutable''. Only use this to build up a brand new string
# object; don't use this if the string may already be known in
# other parts of the code. It is an error to call this function if
# the refcount on the input string object is not one. Pass the
# address of an existing string object as an lvalue (it may be
# written into), and the new size desired. On success, *string
# holds the resized string object and 0 is returned; the address
# in *string may differ from its input value. If the reallocation
# fails, the original string object at *string is deallocated,
# *string is set to NULL, a memory exception is set, and -1 is
# returned.
object PyBytes_Format(object format, object args)
# Return value: New reference. Return a new string object from
# format and args. Analogous to format % args. The args argument
# must be a tuple.
void PyBytes_InternInPlace(PyObject **string)
# Intern the argument *string in place. The argument must be the
# address of a pointer variable pointing to a Python string
# object. If there is an existing interned string that is the same
# as *string, it sets *string to it (decrementing the reference
# count of the old string object and incrementing the reference
# count of the interned string object), otherwise it leaves
# *string alone and interns it (incrementing its reference
# count). (Clarification: even though there is a lot of talk about
# reference counts, think of this function as
# reference-count-neutral; you own the object after the call if
# and only if you owned it before the call.)
object PyBytes_InternFromString(char *v)
# Return value: New reference.
# A combination of PyBytes_FromString() and
# PyBytes_InternInPlace(), returning either a new string object
# that has been interned, or a new (``owned'') reference to an
# earlier interned string object with the same value.
object PyBytes_Decode(char *s, Py_ssize_t size, char *encoding, char *errors)
# Return value: New reference.
# Create an object by decoding size bytes of the encoded buffer s
# using the codec registered for encoding. encoding and errors
# have the same meaning as the parameters of the same name in the
# unicode() built-in function. The codec to be used is looked up
# using the Python codec registry. Return NULL if an exception was
# raised by the codec.
object PyBytes_AsDecodedObject(object str, char *encoding, char *errors)
# Return value: New reference.
# Decode a string object by passing it to the codec registered for
# encoding and return the result as Python object. encoding and
# errors have the same meaning as the parameters of the same name
# in the string encode() method. The codec to be used is looked up
# using the Python codec registry. Return NULL if an exception was
# raised by the codec.
object PyBytes_Encode(char *s, Py_ssize_t size, char *encoding, char *errors)
# Return value: New reference.
# Encode the char buffer of the given size by passing it to the
# codec registered for encoding and return a Python
# object. encoding and errors have the same meaning as the
# parameters of the same name in the string encode() method. The
# codec to be used is looked up using the Python codec
# registry. Return NULL if an exception was raised by the codec.
object PyBytes_AsEncodedObject(object str, char *encoding, char *errors)
# Return value: New reference.
# Encode a string object using the codec registered for encoding
# and return the result as Python object. encoding and errors have
# the same meaning as the parameters of the same name in the
# string encode() method. The codec to be used is looked up using
# the Python codec registry. Return NULL if an exception was
# raised by the codec.
Cython/Includes/cpython/cobject.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
cdef extern from "Python.h":
###########################################################################
# Warning:
#
# The CObject API is deprecated as of Python 3.1. Please switch to
# the new Capsules API.
###########################################################################
int PyCObject_Check(object p)
# Return true if its argument is a PyCObject.
object PyCObject_FromVoidPtr(void* cobj, void (*destr)(void *))
# Return value: New reference.
#
# Create a PyCObject from the void * cobj. The destr function will
# be called when the object is reclaimed, unless it is NULL.
object PyCObject_FromVoidPtrAndDesc(void* cobj, void* desc, void (*destr)(void *, void *))
# Return value: New reference.
#
# Create a PyCObject from the void * cobj. The destr function will
# be called when the object is reclaimed. The desc argument can be
# used to pass extra callback data for the destructor function.
void* PyCObject_AsVoidPtr(object self) except? NULL
# Return the object void * that the PyCObject self was created with.
void* PyCObject_GetDesc(object self) except? NULL
# Return the description void * that the PyCObject self was created with.
int PyCObject_SetVoidPtr(object self, void* cobj) except 0
# Set the void pointer inside self to cobj. The PyCObject must not
# have an associated destructor. Return true on success, false on
# failure.
Cython/Includes/cpython/complex.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "Python.h":
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) except? -1
# Return the real part of op as a C double.
double PyComplex_ImagAsDouble(object op) except? -1
# Return the imaginary part of op as a C double.
Py_complex PyComplex_AsCComplex(object op)
# Return the Py_complex value of the complex number op.
#
# Returns (-1+0i) in case of an error
Cython/Includes/cpython/dict.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
cdef extern from "Python.h":
############################################################################
# 7.4.1 Dictionary Objects
############################################################################
# PyDictObject
#
# This subtype of PyObject represents a Python dictionary object
# (i.e. the 'dict' type).
# PyTypeObject PyDict_Type
#
# This instance of PyTypeObject represents the Python dictionary
# type. This is exposed to Python programs as dict and
# types.DictType.
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) except -1
# Determine if dictionary p contains key. If an item in p is
# matches key, return 1, otherwise return 0. On error, return
# -1. This is equivalent to the Python expression "key in p".
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) except -1
# Insert value into the dictionary p with a key of key. key must
# be hashable; if it isn't, TypeError will be raised. Return 0 on
# success or -1 on failure.
int PyDict_SetItemString(object p, char *key, object val) except -1
# Insert value into the dictionary p using key as a key. key
# should be a char*. The key object is created using
# PyString_FromString(key). Return 0 on success or -1 on failure.
int PyDict_DelItem(object p, object key) except -1
# Remove the entry in dictionary p with key key. key must be
# hashable; if it isn't, TypeError is raised. Return 0 on success
# or -1 on failure.
int PyDict_DelItemString(object p, char *key) except -1
# Remove the entry in dictionary p which has a key specified by
# the string key. Return 0 on success or -1 on failure.
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) except -1
# 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) except -1
# Iterate over mapping object b adding key-value pairs to
# dictionary a. b may be a dictionary, or any object supporting
# PyMapping_Keys() and PyObject_GetItem(). If override is true,
# 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) except -1
# This is the same as PyDict_Merge(a, b, 1) in C, or a.update(b)
# in Python. Return 0 on success or -1 if an exception was raised.
int PyDict_MergeFromSeq2(object a, object seq2, int override) except -1
# Update or merge into dictionary a, from the key-value pairs in
# seq2. seq2 must be an iterable object producing iterable objects
# of length 2, viewed as key-value pairs. In case of duplicate
# 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
Cython/Includes/cpython/exc.pxd 0 → 100644
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/cpython/float.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "Python.h":
############################################################################
# 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) except? -1
# Return a C double representation of the contents of pyfloat.
double PyFloat_AS_DOUBLE(object pyfloat) except? -1
# Return a C double representation of the contents of pyfloat, but
# without error checking.
Cython/Includes/cpython/function.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
cdef extern from "Python.h":
############################################################################
# 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) except? NULL
# Return value: Borrowed reference.
# Return the code object associated with the function object op.
PyObject* PyFunction_GetGlobals(object op) except? NULL
# Return value: Borrowed reference.
# Return the globals dictionary associated with the function object op.
PyObject* PyFunction_GetModule(object op) except? NULL
# Return value: Borrowed reference.
# Return the __module__ attribute of the function object op. This
# is normally a string containing the module name, but can be set
# to any other object by Python code.
PyObject* PyFunction_GetDefaults(object op) except? NULL
# Return value: Borrowed reference.
# Return the argument default values of the function object
# op. This can be a tuple of arguments or NULL.
int PyFunction_SetDefaults(object op, object defaults) except -1
# Set the argument default values for the function object
# op. defaults must be Py_None or a tuple.
# Raises SystemError and returns -1 on failure.
PyObject* PyFunction_GetClosure(object op) except? NULL
# Return value: Borrowed reference.
# Return the closure associated with the function object op. This
# can be NULL or a tuple of cell objects.
int PyFunction_SetClosure(object op, object closure) except -1
# Set the closure associated with the function object op. closure
# must be Py_None or a tuple of cell objects.
# Raises SystemError and returns -1 on failure.
Cython/Includes/cpython/getargs.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
cdef extern from "Python.h":
#####################################################################
# 5.5 Parsing arguments and building values
#####################################################################
ctypedef struct va_list
int PyArg_ParseTuple(object args, char *format, ...) except 0
int PyArg_VaParse(object args, char *format, va_list vargs) except 0
int PyArg_ParseTupleAndKeywords(object args, object kw, char *format, char *keywords[], ...) except 0
int PyArg_VaParseTupleAndKeywords(object args, object kw, char *format, char *keywords[], va_list vargs) except 0
int PyArg_Parse(object args, char *format, ...) except 0
int PyArg_UnpackTuple(object args, char *name, Py_ssize_t min, Py_ssize_t max, ...) except 0
Cython/Includes/cpython/instance.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "Python.h":
############################################################################
# 7.5.2 Instance Objects
############################################################################
# PyTypeObject PyInstance_Type
#
# Type object for class instances.
int PyInstance_Check(object obj)
# Return true if obj is an instance.
object PyInstance_New(object cls, object arg, object kw)
# Return value: New reference.
# Create a new instance of a specific class. The parameters arg
# and kw are used as the positional and keyword parameters to the
# 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.
Cython/Includes/cpython/int.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "Python.h":
ctypedef unsigned long long PY_LONG_LONG
############################################################################
# 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) except? -1
# Will first attempt to cast the object to a PyIntObject, if it is
# not already one, and then return its value. If there is an
# error, -1 is returned, and the caller should check
# 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) except? -1
# Will first attempt to cast the object to a PyIntObject or
# PyLongObject, if it is not already one, and then return its
# value as unsigned long. This function does not check for
# overflow.
PY_LONG_LONG PyInt_AsUnsignedLongLongMask(object io) except? -1
# Will first attempt to cast the object to a PyIntObject or
# PyLongObject, if it is not already one, and then return its
# value as unsigned long long, without checking for overflow.
Py_ssize_t PyInt_AsSsize_t(object io) except? -1
# Will first attempt to cast the object to a PyIntObject or
# PyLongObject, if it is not already one, and then return its
# value as Py_ssize_t.
long PyInt_GetMax()
# Return the system's idea of the largest integer it can handle
# (LONG_MAX, as defined in the system header files).
Cython/Includes/cpython/iterator.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "Python.h":
############################################################################
# 6.5 Iterator Protocol
############################################################################
bint 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 */
# }
Cython/Includes/cpython/list.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
cdef extern from "Python.h":
############################################################################
# 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) except -1
# Return the length of the list object in list; this is equivalent
# to "len(list)" on a list object.
Py_ssize_t PyList_GET_SIZE(object list)
# Macro form of PyList_Size() without error checking.
PyObject* PyList_GetItem(object list, Py_ssize_t index) except NULL
# Return value: Borrowed reference.
# Return the object at position pos in the list pointed to by
# p. The position must be positive, indexing from the end of the
# 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) except -1
# Set the item at index index in list to item. Return 0 on success
# or -1 on failure. Note: This function ``steals'' a reference to
# item and discards a reference to an item already in the list at
# 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) except -1
# Insert the item item into list list in front of index
# index. Return 0 if successful; return -1 and set an exception if
# unsuccessful. Analogous to list.insert(index, item).
int PyList_Append(object list, object item) except -1
# Append the object item at the end of list list. Return 0 if
# successful; return -1 and set an exception if
# unsuccessful. Analogous to list.append(item).
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) except -1
# Set the slice of list between low and high to the contents of
# itemlist. Analogous to list[low:high] = itemlist. The itemlist
# may be NULL, indicating the assignment of an empty list (slice
# deletion). Return 0 on success, -1 on failure.
int PyList_Sort(object list) except -1
# Sort the items of list in place. Return 0 on success, -1 on
# failure. This is equivalent to "list.sort()".
int PyList_Reverse(object list) except -1
# 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)".
Cython/Includes/cpython/long.pxd 0 → 100644
View file @ 44f4ce29
from cpython.unicode cimport Py_UNICODE
cdef extern from "Python.h":
ctypedef long long PY_LONG_LONG
ctypedef unsigned long long uPY_LONG_LONG
############################################################################
# 7.2.3 Long Integer Objects
############################################################################
# PyLongObject
#
# This subtype of PyObject represents a Python long integer object.
# 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(uPY_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) except? -1
# Return a C long representation of the contents of pylong. If
# pylong is greater than LONG_MAX, an OverflowError is raised.
unsigned long PyLong_AsUnsignedLong(object pylong) except? -1
# Return a C unsigned long representation of the contents of
# pylong. If pylong is greater than ULONG_MAX, an OverflowError is
# raised.
PY_LONG_LONG PyLong_AsLongLong(object pylong) except? -1
# Return a C long long from a Python long integer. If pylong
# cannot be represented as a long long, an OverflowError will be
# raised.
uPY_LONG_LONG PyLong_AsUnsignedLongLong(object pylong) except? -1
#unsigned PY_LONG_LONG PyLong_AsUnsignedLongLong(object pylong)
# Return a C unsigned long long from a Python long integer. If
# pylong cannot be represented as an unsigned long long, an
# OverflowError will be raised if the value is positive, or a
# TypeError will be raised if the value is negative.
unsigned long PyLong_AsUnsignedLongMask(object io) except? -1
# Return a C unsigned long from a Python long integer, without
# checking for overflow.
uPY_LONG_LONG PyLong_AsUnsignedLongLongMask(object io) except? -1
#unsigned PY_LONG_LONG PyLong_AsUnsignedLongLongMask(object io)
# Return a C unsigned long long from a Python long integer,
# without checking for overflow.
double PyLong_AsDouble(object pylong) except? -1.0
# Return a C double representation of the contents of pylong. If
# pylong cannot be approximately represented as a double, an
# OverflowError exception is raised and -1.0 will be returned.
void* PyLong_AsVoidPtr(object pylong) except? NULL
# Convert a Python integer or long integer pylong to a C void
# pointer. If pylong cannot be converted, an OverflowError will be
# raised. This is only assured to produce a usable void pointer
# for values created with PyLong_FromVoidPtr(). For values outside
# 0..LONG_MAX, both signed and unsigned integers are acccepted.
Cython/Includes/cpython/mapping.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "Python.h":
############################################################################
# 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) except -1
# Returns the number of keys in object o on success, and -1 on
# failure. For objects that do not provide mapping protocol, this
# is equivalent to the Python expression "len(o)".
int PyMapping_DelItemString(object o, char *key) except -1
# Remove the mapping for object key from the object o. Return -1
# on failure. This is equivalent to the Python statement "del
# o[key]".
int PyMapping_DelItem(object o, object key) except -1
# Remove the mapping for object key from the object o. Return -1
# on failure. This is equivalent to the Python statement "del
# o[key]".
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) except -1
# Map the object key to the value v in object o. Returns -1 on
# failure. This is the equivalent of the Python statement "o[key]
# = v".
Cython/Includes/cpython/mem.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "Python.h":
#####################################################################
# 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().
Cython/Includes/cpython/method.pxd 0 → 100644
View file @ 44f4ce29
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) except NULL
# Return value: Borrowed reference.
# Return the class object from which the method meth was created;
# if this was created from an instance, it will be the class of
# 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) except NULL
# 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) except? NULL
# 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.
Cython/Includes/cpython/module.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
cdef extern from "Python.h":
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) except NULL
# Return value: Borrowed reference.
# Return the module object corresponding to a module name. The
# name argument may be of the form package.module. First check the
# 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() except NULL
# Return value: Borrowed reference.
# Return the dictionary used for the module administration
# (a.k.a. sys.modules). Note that this is a per-interpreter
# variable.
int PyImport_ImportFrozenModule(char *name) except -1
# Load a frozen module named name. Return 1 for success, 0 if the
# module is not found, and -1 with an exception set if the
# initialization failed. To access the imported module on a
# successful load, use PyImport_ImportModule(). (Note the misnomer
# -- this function would reload the module if it was already
# imported.)
int PyImport_ExtendInittab(_inittab *newtab) except -1
# Add a collection of modules to the table of built-in
# modules. The newtab array must end with a sentinel entry which
# contains NULL for the name field; failure to provide the
# 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) except NULL
# Return value: Borrowed reference.
# Return the dictionary object that implements module's namespace;
# this object is the same as the __dict__ attribute of the module
# 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) except NULL
# Return module's __name__ value. If the module does not provide
# one, or if it is not a string, SystemError is raised and NULL is
# returned.
char* PyModule_GetFilename(object module) except NULL
# Return the name of the file from which module was loaded using
# module's __file__ attribute. If this is not defined, or if it is
# not a string, raise SystemError and return NULL.
int PyModule_AddObject(object module, char *name, object value) except -1
# Add an object to module as name. This is a convenience function
# which can be used from the module's initialization
# function. This steals a reference to value. Return -1 on error,
# 0 on success.
int PyModule_AddIntant(object module, char *name, long value) except -1
# Add an integer ant to module as name. This convenience
# function can be used from the module's initialization
# function. Return -1 on error, 0 on success.
int PyModule_AddStringant(object module, char *name, char *value) except -1
# Add a string constant to module as name. This convenience
# function can be used from the module's initialization
# function. The string value must be null-terminated. Return -1 on
# error, 0 on success.
Cython/Includes/cpython/number.pxd 0 → 100644
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/cpython/object.pxd 0 → 100644
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/cpython/oldbuffer.pxd 0 → 100644
View file @ 44f4ce29
# Legacy Python 2 buffer interface.
#
# These functions are no longer available in Python 3, use the new
# buffer interface instead.
cdef extern from "Python.h":
cdef enum _:
Py_END_OF_BUFFER
# This constant may be passed as the size parameter to
# PyBuffer_FromObject() or PyBuffer_FromReadWriteObject(). It
# indicates that the new PyBufferObject should refer to base object
# from the specified offset to the end of its exported
# buffer. Using this enables the caller to avoid querying the base
# object for its length.
bint PyBuffer_Check(object p)
# Return true if the argument has type PyBuffer_Type.
object PyBuffer_FromObject(object base, Py_ssize_t offset, Py_ssize_t size)
# Return value: New reference.
#
# Return a new read-only buffer object. This raises TypeError if
# base doesn't support the read-only buffer protocol or doesn't
# provide exactly one buffer segment, or it raises ValueError if
# offset is less than zero. The buffer will hold a reference to the
# base object, and the buffer's contents will refer to the base
# object's buffer interface, starting as position offset and
# extending for size bytes. If size is Py_END_OF_BUFFER, then the
# new buffer's contents extend to the length of the base object's
# exported buffer data.
object PyBuffer_FromReadWriteObject(object base, Py_ssize_t offset, Py_ssize_t size)
# Return value: New reference.
#
# Return a new writable buffer object. Parameters and exceptions
# are similar to those for PyBuffer_FromObject(). If the base
# object does not export the writeable buffer protocol, then
# TypeError is raised.
object PyBuffer_FromMemory(void *ptr, Py_ssize_t size)
# Return value: New reference.
#
# Return a new read-only buffer object that reads from a specified
# location in memory, with a specified size. The caller is
# responsible for ensuring that the memory buffer, passed in as
# ptr, is not deallocated while the returned buffer object
# exists. Raises ValueError if size is less than zero. Note that
# Py_END_OF_BUFFER may not be passed for the size parameter;
# ValueError will be raised in that case.
object PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size)
# Return value: New reference.
#
# Similar to PyBuffer_FromMemory(), but the returned buffer is
# writable.
object PyBuffer_New(Py_ssize_t size)
# Return value: New reference.
#
# Return a new writable buffer object that maintains its own memory
# buffer of size bytes. ValueError is returned if size is not zero
# or positive. Note that the memory buffer (as returned by
# PyObject_AsWriteBuffer()) is not specifically aligned.
Cython/Includes/cpython/pycapsule.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
# available since Python 3.1!
# note all char* in the below functions are actually const char*
cdef extern from "Python.h":
ctypedef struct PyCapsule_Type
# This subtype of PyObject represents an opaque value, useful for
# C extension modules who need to pass an opaque value (as a void*
# pointer) through Python code to other C code. It is often used
# to make a C function pointer defined in one module available to
# other modules, so the regular import mechanism can be used to
# access C APIs defined in dynamically loaded modules.
ctypedef void (*PyCapsule_Destructor)(object o)
# The type of a destructor callback for a capsule.
#
# See PyCapsule_New() for the semantics of PyCapsule_Destructor
# callbacks.
bint PyCapsule_CheckExact(object o)
# Return true if its argument is a PyCapsule.
object PyCapsule_New(void *pointer, char *name,
PyCapsule_Destructor destructor)
# Return value: New reference.
#
# Create a PyCapsule encapsulating the pointer. The pointer
# argument may not be NULL.
#
# On failure, set an exception and return NULL.
#
# The name string may either be NULL or a pointer to a valid C
# string. If non-NULL, this string must outlive the
# capsule. (Though it is permitted to free it inside the
# destructor.)
#
# If the destructor argument is not NULL, it will be called with
# the capsule as its argument when it is destroyed.
#
# If this capsule will be stored as an attribute of a module, the
# name should be specified as modulename.attributename. This will
# enable other modules to import the capsule using
# PyCapsule_Import().
void* PyCapsule_GetPointer(object capsule, char *name) except? NULL
# Retrieve the pointer stored in the capsule. On failure, set an
# exception and return NULL.
#
# The name parameter must compare exactly to the name stored in
# the capsule. If the name stored in the capsule is NULL, the name
# passed in must also be NULL. Python uses the C function strcmp()
# to compare capsule names.
PyCapsule_Destructor PyCapsule_GetDestructor(object capsule) except? NULL
# Return the current destructor stored in the capsule. On failure,
# set an exception and return NULL.
#
# It is legal for a capsule to have a NULL destructor. This makes
# a NULL return code somewhat ambiguous; use PyCapsule_IsValid()
# or PyErr_Occurred() to disambiguate.
char* PyCapsule_GetName(object capsule) except? NULL
# Return the current name stored in the capsule. On failure, set
# an exception and return NULL.
#
# It is legal for a capsule to have a NULL name. This makes a NULL
# return code somewhat ambiguous; use PyCapsule_IsValid() or
# PyErr_Occurred() to disambiguate.
void* PyCapsule_GetContext(object capsule) except? NULL
# Return the current context stored in the capsule. On failure,
# set an exception and return NULL.
#
# It is legal for a capsule to have a NULL context. This makes a
# NULL return code somewhat ambiguous; use PyCapsule_IsValid() or
# PyErr_Occurred() to disambiguate.
bint PyCapsule_IsValid(object capsule, char *name)
# Determines whether or not capsule is a valid capsule. A valid
# capsule is non-NULL, passes PyCapsule_CheckExact(), has a
# non-NULL pointer stored in it, and its internal name matches the
# name parameter. (See PyCapsule_GetPointer() for information on
# how capsule names are compared.)
#
# In other words, if PyCapsule_IsValid() returns a true value,
# calls to any of the accessors (any function starting with
# PyCapsule_Get()) are guaranteed to succeed.
#
# Return a nonzero value if the object is valid and matches the
# name passed in. Return 0 otherwise. This function will not fail.
int PyCapsule_SetPointer(object capsule, void *pointer) except -1
# Set the void pointer inside capsule to pointer. The pointer may
# not be NULL.
#
# Return 0 on success. Return nonzero and set an exception on
# failure.
int PyCapsule_SetDestructor(object capsule, PyCapsule_Destructor destructor) except -1
# Set the destructor inside capsule to destructor.
#
# Return 0 on success. Return nonzero and set an exception on
# failure.
int PyCapsule_SetName(object capsule, char *name) except -1
# Set the name inside capsule to name. If non-NULL, the name must
# outlive the capsule. If the previous name stored in the capsule
# was not NULL, no attempt is made to free it.
#
# Return 0 on success. Return nonzero and set an exception on
# failure.
int PyCapsule_SetContext(object capsule, void *context) except -1
# Set the context pointer inside capsule to context. Return 0 on
# success. Return nonzero and set an exception on failure.
void* PyCapsule_Import(char *name, int no_block) except? NULL
# Import a pointer to a C object from a capsule attribute in a
# module. The name parameter should specify the full name to the
# attribute, as in module.attribute. The name stored in the
# capsule must match this string exactly. If no_block is true,
# import the module without blocking (using
# PyImport_ImportModuleNoBlock()). If no_block is false, import
# the module conventionally (using PyImport_ImportModule()).
#
# Return the capsule’s internal pointer on success. On failure,
# set an exception and return NULL. However, if PyCapsule_Import()
# failed to import the module, and no_block was true, no exception
# is set.
Cython/Includes/cpython/ref.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "Python.h":
ctypedef struct PyTypeObject
ctypedef struct PyObject:
Py_ssize_t ob_refcnt
PyTypeObject *ob_type
#####################################################################
# 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(PyObject* 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(PyObject* 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(PyObject* 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.
Cython/Includes/cpython/sequence.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
cdef extern from "Python.h":
############################################################################
# 6.3 Sequence Protocol
############################################################################
bint PySequence_Check(object o)
# Return 1 if the object provides sequence protocol, and 0
# otherwise. This function always succeeds.
Py_ssize_t PySequence_Size(object o) except -1
# Returns the number of objects in sequence o on success, and -1
# on failure. For objects that do not provide sequence protocol,
# this is equivalent to the Python expression "len(o)".
Py_ssize_t PySequence_Length(object o) except -1
# 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) except -1
# Assign object v to the ith element of o. Returns -1 on
# failure. This is the equivalent of the Python statement "o[i] =
# v". This function does not steal a reference to v.
int PySequence_DelItem(object o, Py_ssize_t i) except -1
# Delete the ith element of object o. Returns -1 on failure. This
# is the equivalent of the Python statement "del o[i]".
int PySequence_SetSlice(object o, Py_ssize_t i1, Py_ssize_t i2, object v) except -1
# Assign the sequence object v to the slice in sequence object o
# from i1 to i2. This is the equivalent of the Python statement
# "o[i1:i2] = v".
int PySequence_DelSlice(object o, Py_ssize_t i1, Py_ssize_t i2) except -1
# Delete the slice in sequence object o from i1 to i2. Returns -1
# on failure. This is the equivalent of the Python statement "del
# o[i1:i2]".
int PySequence_Count(object o, object value) except -1
# Return the number of occurrences of value in o, that is, return
# the number of keys for which o[key] == value. On failure, return
# -1. This is equivalent to the Python expression
# "o.count(value)".
int PySequence_Contains(object o, object value) except -1
# Determine if o contains value. If an item in o is equal to
# value, return 1, otherwise return 0. On error, return -1. This
# is equivalent to the Python expression "value in o".
int PySequence_Index(object o, object value) except -1
# Return the first index i for which o[i] == value. On error,
# return -1. This is equivalent to the Python expression
# "o.index(value)".
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.
Cython/Includes/cpython/set.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "Python.h":
############################################################################
# 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.
object PySet_New(object iterable)
# Return value: New reference.
# Return a new set containing objects returned by the
# iterable. The iterable may be NULL to create a new empty
# 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)).
object PyFrozenSet_New(object iterable)
# Return value: New reference.
# Return a new frozenset containing objects returned by the
# iterable. The iterable may be NULL to create a new empty
# 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) except -1
# Return the length of a set or frozenset object. Equivalent to
# "len(anyset)". Raises a PyExc_SystemError if anyset is not a
# set, frozenset, or an instance of a subtype.
int PySet_GET_SIZE(object anyset)
# Macro form of PySet_Size() without error checking.
bint PySet_Contains(object anyset, object key) except -1
# Return 1 if found, 0 if not found, and -1 if an error is
# encountered. Unlike the Python __contains__() method, this
# function does not automatically convert unhashable sets into
# 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) except -1
# Add key to a set instance. Does not apply to frozenset
# instances. Return 0 on success or -1 on failure. Raise a
# TypeError if the key is unhashable. Raise a MemoryError if there
# is no room to grow. Raise a SystemError if set is an not an
# instance of set or its subtype.
bint PySet_Discard(object set, object key) except -1
# Return 1 if found and removed, 0 if not found (no action taken),
# and -1 if an error is encountered. Does not raise KeyError for
# missing keys. Raise a TypeError if the key is unhashable. Unlike
# 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.
object PySet_Pop(object set)
# Return value: New reference.
# Return a new reference to an arbitrary object in the set, and
# removes the object from the set. Return NULL on failure. Raise
# 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.
Cython/Includes/cpython/string.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
cdef extern from "Python.h":
ctypedef struct va_list
############################################################################
# 7.3.1 String Objects
############################################################################
# These functions raise TypeError when expecting a string
# parameter and are called with a non-string parameter.
# PyStringObject
# This subtype of PyObject represents a Python 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) except -1
# 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) except NULL
# Return a NUL-terminated representation of the contents of
# string. The pointer refers to the internal buffer of string, not
# a copy. The data must not be modified in any way, unless the
# string was just created using 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) except -1
# Return a NULL-terminated representation of the contents of the
# object obj through the output variables buffer and length.
#
# The function accepts both string and Unicode objects as
# input. For Unicode objects it returns the default encoded
# version of the object. If length is NULL, the resulting buffer
# may not contain NUL characters; if it does, the function returns
# -1 and a TypeError is raised.
# The buffer refers to an internal string buffer of obj, not a
# copy. The data must not be modified in any way, unless the
# string was just created using 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) except -1
# A way to resize a string object even though it is
# ``immutable''. Only use this to build up a brand new string
# object; don't use this if the string may already be known in
# other parts of the code. It is an error to call this function if
# the refcount on the input string object is not one. Pass the
# address of an existing string object as an lvalue (it may be
# written into), and the new size desired. On success, *string
# holds the resized string object and 0 is returned; the address
# in *string may differ from its input value. If the reallocation
# fails, the original string object at *string is deallocated,
# *string is set to NULL, a memory exception is set, and -1 is
# returned.
object 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.
Cython/Includes/cpython/tuple.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
cdef extern from "Python.h":
############################################################################
# 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) except -1
# 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) except NULL
# Return value: Borrowed reference.
# Return the object at position pos in the tuple pointed to by
# p. If pos is out of bounds, return NULL and sets an IndexError
# 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) except -1
# Can be used to resize a tuple. newsize will be the new length of
# the tuple. Because tuples are supposed to be immutable, this
# should only be used if there is only one reference to the
# 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.
Cython/Includes/cpython/type.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "Python.h":
# 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) except -1
# Finalize a type object. This should be called on all type
# objects to finish their initialization. This function is
# responsible for adding inherited slots from a type's base
# class. Return 0 on success, or return -1 and sets an exception
# on error.
Cython/Includes/cpython/unicode.pxd 0 → 100644
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/cpython/version.pxd 0 → 100644
View file @ 44f4ce29
# Python version constants
#
# It's better to evaluate these at runtime (i.e. C compile time) using
#
# if PY_MAJOR_VERSION >= 3:
# do_stuff_in_Py3_0_and_later()
# if PY_VERSION_HEX >= 0x02050000:
# do_stuff_in_Py2_5_and_later()
#
# than using the IF/DEF statements, which are evaluated at Cython
# compile time. This will keep your C code portable.
cdef extern from *:
# the complete version, e.g. 0x010502B2 == 1.5.2b2
int PY_VERSION_HEX
# the individual sections as plain numbers
int PY_MAJOR_VERSION
int PY_MINOR_VERSION
int PY_MICRO_VERSION
int PY_RELEASE_LEVEL
int PY_RELEASE_SERIAL
# Note: PY_RELEASE_LEVEL is one of
# 0xA (alpha)
# 0xB (beta)
# 0xC (release candidate)
# 0xF (final)
char PY_VERSION[]
char PY_PATCHLEVEL_REVISION[]
Cython/Includes/cpython/weakref.pxd 0 → 100644
View file @ 44f4ce29
from cpython.ref cimport PyObject
cdef extern from "Python.h":
bint PyWeakref_Check(object ob)
# Return true if ob is either a reference or proxy object.
bint PyWeakref_CheckRef(object ob)
# Return true if ob is a reference object.
bint PyWeakref_CheckProxy(ob)
# Return true if *ob* is a proxy object.
object PyWeakref_NewRef(object ob, object callback)
# Return a weak reference object for the object ob. This will
# always return a new reference, but is not guaranteed to create a
# new object; an existing reference object may be returned. The
# second parameter, callback, can be a callable object that
# receives notification when ob is garbage collected; it should
# accept a single parameter, which will be the weak reference
# object itself. callback may also be None or NULL. If ob is not
# a weakly-referencable object, or if callback is not callable,
# None, or NULL, this will return NULL and raise TypeError.
object PyWeakref_NewProxy(object ob, object callback)
# Return a weak reference proxy object for the object ob. This
# will always return a new reference, but is not guaranteed to
# create a new object; an existing proxy object may be returned.
# The second parameter, callback, can be a callable object that
# receives notification when ob is garbage collected; it should
# accept a single parameter, which will be the weak reference
# object itself. callback may also be None or NULL. If ob is not
# a weakly-referencable object, or if callback is not callable,
# None, or NULL, this will return NULL and raise TypeError.
PyObject* PyWeakref_GetObject(object ref)
# Return the referenced object from a weak reference, ref. If the
# referent is no longer live, returns None.
PyObject* PyWeakref_GET_OBJECT(object ref)
# Similar to PyWeakref_GetObject, but implemented as a macro that
# does no error checking.
Cython/Includes/libc/stdio.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "stdio.h" nogil:
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, ...)
Cython/Includes/libc/stdlib.pxd 0 → 100644
View file @ 44f4ce29
cdef extern from "stdlib.h" nogil:
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)
Cython/Includes/python.pxd
View file @ 44f4ce29
#####################################################################
#
# These are the Cython pxd files for (most of) the Python/C API.
#
# REFERENCE COUNTING:
#
# JUST TO SCARE YOU:
# If you are going to use any of the Python/C API in your Cython
# 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 Cython 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 Cython 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. Cython will use the latest
# declaration.
#
# Cython 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.
#
#################################################################
from python_version cimport *
from python_ref cimport *
from python_exc cimport *
from python_module cimport *
from python_mem cimport *
from python_tuple cimport *
from python_list cimport *
from python_object cimport *
from python_sequence cimport *
from python_mapping cimport *
from python_iterator cimport *
from python_type cimport *
from python_number cimport *
from python_int cimport *
from python_bool cimport *
from python_long cimport *
from python_float cimport *
from python_complex cimport *
from python_string cimport *
from python_unicode cimport *
from python_dict cimport *
from python_instance cimport *
from python_function cimport *
from python_method cimport *
from python_weakref cimport *
from python_getargs cimport *
# Python <= 2.x
from python_cobject cimport *
from python_oldbuffer cimport *
# Python >= 2.4
from python_set cimport *
# Python >= 2.6
from python_buffer cimport *
from python_bytes cimport *
# Python >= 3.0
from python_pycapsule cimport *
# Present for backwards compatability
from cpython cimport *
Cython/Includes/python_bool.pxd
View file @ 44f4ce29
cdef extern from "Python.h":
############################################################################
# 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.
# Present for backwards compatability
from cpython.bool cimport *
Cython/Includes/python_buffer.pxd
View file @ 44f4ce29
# Please see the Python header files (object.h/abstract.h) for docs
cdef extern from "Python.h":
cdef enum:
PyBUF_SIMPLE,
PyBUF_WRITABLE,
PyBUF_WRITEABLE, # backwards compatability
PyBUF_FORMAT,
PyBUF_ND,
PyBUF_STRIDES,
PyBUF_C_CONTIGUOUS,
PyBUF_F_CONTIGUOUS,
PyBUF_ANY_CONTIGUOUS,
PyBUF_INDIRECT,
PyBUF_CONTIG,
PyBUF_CONTIG_RO,
PyBUF_STRIDED,
PyBUF_STRIDED_RO,
PyBUF_RECORDS,
PyBUF_RECORDS_RO,
PyBUF_FULL,
PyBUF_FULL_RO,
PyBUF_READ,
PyBUF_WRITE,
PyBUF_SHADOW
bint PyObject_CheckBuffer(object obj)
# Return 1 if obj supports the buffer interface otherwise 0.
int PyObject_GetBuffer(object obj, Py_buffer *view, int flags) except -1
# Export obj into a Py_buffer, view. These arguments must never be
# NULL. The flags argument is a bit field indicating what kind of
# buffer the caller is prepared to deal with and therefore what
# kind of buffer the exporter is allowed to return. The buffer
# interface allows for complicated memory sharing possibilities,
# but some caller may not be able to handle all the complexity but
# may want to see if the exporter will let them take a simpler
# view to its memory.
# Some exporters may not be able to share memory in every possible
# way and may need to raise errors to signal to some consumers
# that something is just not possible. These errors should be a
# BufferError unless there is another error that is actually
# causing the problem. The exporter can use flags information to
# simplify how much of the Py_buffer structure is filled in with
# non-default values and/or raise an error if the object can’t
# support a simpler view of its memory.
# 0 is returned on success and -1 on error.
void PyBuffer_Release(object obj, object view)
# Release the buffer view over obj. This should be called when the
# buffer is no longer being used as it may free memory from it.
void* PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)
# ??
int PyBuffer_SizeFromFormat(char *) # actually const char
# Return the implied ~Py_buffer.itemsize from the struct-stype
# ~Py_buffer.format
int PyBuffer_ToContiguous(void *buf, Py_buffer *view, Py_ssize_t len, char fort)
# ??
int PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)
# ??
int PyObject_CopyToObject(object obj, void *buf, Py_ssize_t len, char fortran) except -1
# Copy len bytes of data pointed to by the contiguous chunk of
# memory pointed to by buf into the buffer exported by obj. The
# buffer must of course be writable. Return 0 on success and
# return -1 and raise an error on failure. If the object does not
# have a writable buffer, then an error is raised. If fortran is
# 'F', then if the object is multi-dimensional, then the data will
# be copied into the array in Fortran-style (first dimension
# varies the fastest). If fortran is 'C', then the data will be
# copied into the array in C-style (last dimension varies the
# fastest). If fortran is 'A', then it does not matter and the
# copy will be made in whatever way is more efficient.
int PyObject_CopyData(object dest, object src) except -1
# Copy the data from the src buffer to the buffer of destination
bint PyBuffer_IsContiguous(Py_buffer *view, char fort)
# Return 1 if the memory defined by the view is C-style (fortran
# is 'C') or Fortran-style (fortran is 'F') contiguous or either
# one (fortran is 'A'). Return 0 otherwise.
void PyBuffer_FillContiguousStrides(int ndims,
Py_ssize_t *shape,
Py_ssize_t *strides,
int itemsize,
char fort)
# Fill the strides array with byte-strides of a contiguous
# (Fortran-style if fort is 'F' or C-style otherwise) array of the
# given shape with the given number of bytes per element.
int PyBuffer_FillInfo(Py_buffer *view, void *buf,
Py_ssize_t len, int readonly,
int flags) except -1
# Fill in a buffer-info structure, view, correctly for an exporter
# that can only share a contiguous chunk of memory of “unsigned
# bytes” of the given length. Return 0 on success and -1 (with
# raising an error) on error.
object PyObject_Format(object obj, object format_spec)
# Takes an arbitrary object and returns the result of calling
# obj.__format__(format_spec).
# Present for backwards compatability
from cpython.buffer cimport *
Cython/Includes/python_bytes.pxd
View file @ 44f4ce29
from python_ref cimport PyObject
cdef extern from "Python.h":
ctypedef struct va_list
############################################################################
# 7.3.1 String Objects
############################################################################
# These functions raise TypeError when expecting a string
# parameter and are called with a non-string parameter.
# PyStringObject
# This subtype of PyObject represents a Python bytes object.
# PyTypeObject PyBytes_Type
# This instance of PyTypeObject represents the Python bytes type;
# it is the same object as bytes and types.BytesType in the Python
# layer.
bint PyBytes_Check(object o)
# Return true if the object o is a string object or an instance of
# a subtype of the string type.
bint PyBytes_CheckExact(object o)
# Return true if the object o is a string object, but not an instance of a subtype of the string type.
object PyBytes_FromString(char *v)
# Return value: New reference.
# Return a new string object with the value v on success, and NULL
# on failure. The parameter v must not be NULL; it will not be
# checked.
object PyBytes_FromStringAndSize(char *v, Py_ssize_t len)
# Return value: New reference.
# Return a new string object with the value v and length len on
# success, and NULL on failure. If v is NULL, the contents of the
# string are uninitialized.
object PyBytes_FromFormat(char *format, ...)
# Return value: New reference.
# Take a C printf()-style format string and a variable number of
# arguments, calculate the size of the resulting Python string and
# return a string with the values formatted into it. The variable
# arguments must be C types and must correspond exactly to the
# format characters in the format string. The following format
# characters are allowed:
# Format Characters Type Comment
# %% n/a The literal % character.
# %c int A single character, represented as an C int.
# %d int Exactly equivalent to printf("%d").
# %u unsigned int Exactly equivalent to printf("%u").
# %ld long Exactly equivalent to printf("%ld").
# %lu unsigned long Exactly equivalent to printf("%lu").
# %zd Py_ssize_t Exactly equivalent to printf("%zd").
# %zu size_t Exactly equivalent to printf("%zu").
# %i int Exactly equivalent to printf("%i").
# %x int Exactly equivalent to printf("%x").
# %s char* A null-terminated C character array.
# %p void* The hex representation of a C pointer.
# Mostly equivalent to printf("%p") except that it is guaranteed to
# start with the literal 0x regardless of what the platform's printf
# yields.
# An unrecognized format character causes all the rest of the
# format string to be copied as-is to the result string, and any
# extra arguments discarded.
object PyBytes_FromFormatV(char *format, va_list vargs)
# Return value: New reference.
# Identical to PyBytes_FromFormat() except that it takes exactly two arguments.
Py_ssize_t PyBytes_Size(object string) except -1
# Return the length of the string in string object string.
Py_ssize_t PyBytes_GET_SIZE(object string)
# Macro form of PyBytes_Size() but without error checking.
char* PyBytes_AsString(object string) except NULL
# Return a NUL-terminated representation of the contents of
# string. The pointer refers to the internal buffer of string, not
# a copy. The data must not be modified in any way, unless the
# string was just created using PyBytes_FromStringAndSize(NULL,
# size). It must not be deallocated. If string is a Unicode
# object, this function computes the default encoding of string
# and operates on that. If string is not a string object at all,
# PyBytes_AsString() returns NULL and raises TypeError.
char* PyBytes_AS_STRING(object string)
# Macro form of PyBytes_AsString() but without error
# checking. Only string objects are supported; no Unicode objects
# should be passed.
int PyBytes_AsStringAndSize(object obj, char **buffer, Py_ssize_t *length) except -1
# Return a NULL-terminated representation of the contents of the
# object obj through the output variables buffer and length.
#
# The function accepts both string and Unicode objects as
# input. For Unicode objects it returns the default encoded
# version of the object. If length is NULL, the resulting buffer
# may not contain NUL characters; if it does, the function returns
# -1 and a TypeError is raised.
# The buffer refers to an internal string buffer of obj, not a
# copy. The data must not be modified in any way, unless the
# string was just created using PyBytes_FromStringAndSize(NULL,
# size). It must not be deallocated. If string is a Unicode
# object, this function computes the default encoding of string
# and operates on that. If string is not a string object at all,
# PyBytes_AsStringAndSize() returns -1 and raises TypeError.
void PyBytes_Concat(PyObject **string, object newpart)
# Create a new string object in *string containing the contents of
# newpart appended to string; the caller will own the new
# reference. The reference to the old value of string will be
# stolen. If the new string cannot be created, the old reference
# to string will still be discarded and the value of *string will
# be set to NULL; the appropriate exception will be set.
void PyBytes_ConcatAndDel(PyObject **string, object newpart)
# Create a new string object in *string containing the contents of
# newpart appended to string. This version decrements the
# reference count of newpart.
int _PyBytes_Resize(PyObject **string, Py_ssize_t newsize) except -1
# A way to resize a string object even though it is
# ``immutable''. Only use this to build up a brand new string
# object; don't use this if the string may already be known in
# other parts of the code. It is an error to call this function if
# the refcount on the input string object is not one. Pass the
# address of an existing string object as an lvalue (it may be
# written into), and the new size desired. On success, *string
# holds the resized string object and 0 is returned; the address
# in *string may differ from its input value. If the reallocation
# fails, the original string object at *string is deallocated,
# *string is set to NULL, a memory exception is set, and -1 is
# returned.
object PyBytes_Format(object format, object args)
# Return value: New reference. Return a new string object from
# format and args. Analogous to format % args. The args argument
# must be a tuple.
void PyBytes_InternInPlace(PyObject **string)
# Intern the argument *string in place. The argument must be the
# address of a pointer variable pointing to a Python string
# object. If there is an existing interned string that is the same
# as *string, it sets *string to it (decrementing the reference
# count of the old string object and incrementing the reference
# count of the interned string object), otherwise it leaves
# *string alone and interns it (incrementing its reference
# count). (Clarification: even though there is a lot of talk about
# reference counts, think of this function as
# reference-count-neutral; you own the object after the call if
# and only if you owned it before the call.)
object PyBytes_InternFromString(char *v)
# Return value: New reference.
# A combination of PyBytes_FromString() and
# PyBytes_InternInPlace(), returning either a new string object
# that has been interned, or a new (``owned'') reference to an
# earlier interned string object with the same value.
object PyBytes_Decode(char *s, Py_ssize_t size, char *encoding, char *errors)
# Return value: New reference.
# Create an object by decoding size bytes of the encoded buffer s
# using the codec registered for encoding. encoding and errors
# have the same meaning as the parameters of the same name in the
# unicode() built-in function. The codec to be used is looked up
# using the Python codec registry. Return NULL if an exception was
# raised by the codec.
object PyBytes_AsDecodedObject(object str, char *encoding, char *errors)
# Return value: New reference.
# Decode a string object by passing it to the codec registered for
# encoding and return the result as Python object. encoding and
# errors have the same meaning as the parameters of the same name
# in the string encode() method. The codec to be used is looked up
# using the Python codec registry. Return NULL if an exception was
# raised by the codec.
object PyBytes_Encode(char *s, Py_ssize_t size, char *encoding, char *errors)
# Return value: New reference.
# Encode the char buffer of the given size by passing it to the
# codec registered for encoding and return a Python
# object. encoding and errors have the same meaning as the
# parameters of the same name in the string encode() method. The
# codec to be used is looked up using the Python codec
# registry. Return NULL if an exception was raised by the codec.
object PyBytes_AsEncodedObject(object str, char *encoding, char *errors)
# Return value: New reference.
# Encode a string object using the codec registered for encoding
# and return the result as Python object. encoding and errors have
# the same meaning as the parameters of the same name in the
# string encode() method. The codec to be used is looked up using
# the Python codec registry. Return NULL if an exception was
# raised by the codec.
# Present for backwards compatability
from cpython.bytes cimport *
Cython/Includes/python_cobject.pxd
View file @ 44f4ce29
from python_ref cimport PyObject
cdef extern from "Python.h":
###########################################################################
# Warning:
#
# The CObject API is deprecated as of Python 3.1. Please switch to
# the new Capsules API.
###########################################################################
int PyCObject_Check(object p)
# Return true if its argument is a PyCObject.
object PyCObject_FromVoidPtr(void* cobj, void (*destr)(void *))
# Return value: New reference.
#
# Create a PyCObject from the void * cobj. The destr function will
# be called when the object is reclaimed, unless it is NULL.
object PyCObject_FromVoidPtrAndDesc(void* cobj, void* desc, void (*destr)(void *, void *))
# Return value: New reference.
#
# Create a PyCObject from the void * cobj. The destr function will
# be called when the object is reclaimed. The desc argument can be
# used to pass extra callback data for the destructor function.
void* PyCObject_AsVoidPtr(object self) except? NULL
# Return the object void * that the PyCObject self was created with.
void* PyCObject_GetDesc(object self) except? NULL
# Return the description void * that the PyCObject self was created with.
int PyCObject_SetVoidPtr(object self, void* cobj) except 0
# Set the void pointer inside self to cobj. The PyCObject must not
# have an associated destructor. Return true on success, false on
# failure.
# Present for backwards compatability
from cpython.cobject cimport *
Cython/Includes/python_complex.pxd
View file @ 44f4ce29
cdef extern from "Python.h":
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) except? -1
# Return the real part of op as a C double.
double PyComplex_ImagAsDouble(object op) except? -1
# Return the imaginary part of op as a C double.
Py_complex PyComplex_AsCComplex(object op)
# Return the Py_complex value of the complex number op.
#
# Returns (-1+0i) in case of an error
# Present for backwards compatability
from cpython.complex cimport *
Cython/Includes/python_dict.pxd
View file @ 44f4ce29
from python_ref cimport PyObject
cdef extern from "Python.h":
############################################################################
# 7.4.1 Dictionary Objects
############################################################################
# PyDictObject
#
# This subtype of PyObject represents a Python dictionary object
# (i.e. the 'dict' type).
# PyTypeObject PyDict_Type
#
# This instance of PyTypeObject represents the Python dictionary
# type. This is exposed to Python programs as dict and
# types.DictType.
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) except -1
# Determine if dictionary p contains key. If an item in p is
# matches key, return 1, otherwise return 0. On error, return
# -1. This is equivalent to the Python expression "key in p".
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) except -1
# Insert value into the dictionary p with a key of key. key must
# be hashable; if it isn't, TypeError will be raised. Return 0 on
# success or -1 on failure.
int PyDict_SetItemString(object p, char *key, object val) except -1
# Insert value into the dictionary p using key as a key. key
# should be a char*. The key object is created using
# PyString_FromString(key). Return 0 on success or -1 on failure.
int PyDict_DelItem(object p, object key) except -1
# Remove the entry in dictionary p with key key. key must be
# hashable; if it isn't, TypeError is raised. Return 0 on success
# or -1 on failure.
int PyDict_DelItemString(object p, char *key) except -1
# Remove the entry in dictionary p which has a key specified by
# the string key. Return 0 on success or -1 on failure.
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) except -1
# 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) except -1
# Iterate over mapping object b adding key-value pairs to
# dictionary a. b may be a dictionary, or any object supporting
# PyMapping_Keys() and PyObject_GetItem(). If override is true,
# 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) except -1
# This is the same as PyDict_Merge(a, b, 1) in C, or a.update(b)
# in Python. Return 0 on success or -1 if an exception was raised.
int PyDict_MergeFromSeq2(object a, object seq2, int override) except -1
# Update or merge into dictionary a, from the key-value pairs in
# seq2. seq2 must be an iterable object producing iterable objects
# of length 2, viewed as key-value pairs. In case of duplicate
# 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
# Present for backwards compatability
from cpython.dict cimport *
Cython/Includes/python_exc.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_float.pxd
View file @ 44f4ce29
cdef extern from "Python.h":
############################################################################
# 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) except? -1
# Return a C double representation of the contents of pyfloat.
double PyFloat_AS_DOUBLE(object pyfloat) except? -1
# Return a C double representation of the contents of pyfloat, but
# without error checking.
# Present for backwards compatability
from cpython.float cimport *
Cython/Includes/python_function.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_getargs.pxd
View file @ 44f4ce29
from python_ref cimport PyObject
cdef extern from "Python.h":
#####################################################################
# 5.5 Parsing arguments and building values
#####################################################################
ctypedef struct va_list
int PyArg_ParseTuple(object args, char *format, ...) except 0
int PyArg_VaParse(object args, char *format, va_list vargs) except 0
int PyArg_ParseTupleAndKeywords(object args, object kw, char *format, char *keywords[], ...) except 0
int PyArg_VaParseTupleAndKeywords(object args, object kw, char *format, char *keywords[], va_list vargs) except 0
int PyArg_Parse(object args, char *format, ...) except 0
int PyArg_UnpackTuple(object args, char *name, Py_ssize_t min, Py_ssize_t max, ...) except 0
# Present for backwards compatability
from cpython.getargs cimport *
Cython/Includes/python_instance.pxd
View file @ 44f4ce29
cdef extern from "Python.h":
############################################################################
# 7.5.2 Instance Objects
############################################################################
# PyTypeObject PyInstance_Type
#
# Type object for class instances.
int PyInstance_Check(object obj)
# Return true if obj is an instance.
object PyInstance_New(object cls, object arg, object kw)
# Return value: New reference.
# Create a new instance of a specific class. The parameters arg
# and kw are used as the positional and keyword parameters to the
# 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.
# Present for backwards compatability
from cpython.instance cimport *
Cython/Includes/python_int.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_iterator.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_list.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_long.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_mapping.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_mem.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_method.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_module.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_number.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_object.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_oldbuffer.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_pycapsule.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_ref.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_sequence.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_set.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_string.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_tuple.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_type.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_unicode.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_version.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/python_weakref.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Includes/stdio.pxd
View file @ 44f4ce29
cdef extern from "stdio.h" nogil:
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, ...)
# Present for backwards compatability
from libc.stdio cimport *
Cython/Includes/stdlib.pxd
View file @ 44f4ce29
This diff is collapsed.
Cython/Plex/test_tm.py deleted 100644 → 0
View file @ cec8145d
This diff is collapsed.
Cython/Runtime/refnanny.pyx
View file @ 44f4ce29
This diff is collapsed.
Cython/Tests/xmlrunner.py
View file @ 44f4ce29
This diff is collapsed.
Demos/embed/Makefile
View file @ 44f4ce29
This diff is collapsed.
Makefile
View file @ 44f4ce29
......@@ -22,7 +22,7 @@ repo: .hg
clean:
@echo Cleaning Source
@rm -fr build
@rm -f *.pyc */*.pyc */*/*.pyc
@rm -f *.py[co] */*.py[co] */*/*.py[co] */*/*/*.py[co]
@rm -f *.so */*.so */*/*.so
@rm -f *.pyd */*.pyd */*/*.pyd
@rm -f *~ */*~ */*/*~
......
runtests.py
View file @ 44f4ce29
This diff is collapsed.
setup.py
View file @ 44f4ce29
This diff is collapsed.
tests/compile/extpymemberdef.pyx
View file @ 44f4ce29
This diff is collapsed.
tests/errors/cdef_members_T517.pyx 0 → 100644
View file @ 44f4ce29
This diff is collapsed.
tests/errors/e_extweakref.pyx
View file @ 44f4ce29
This diff is collapsed.
tests/run/cdef_members_T517.pyx 0 → 100644
View file @ 44f4ce29
This diff is collapsed.
tests/run/cython_includes.pyx 0 → 100644
View file @ 44f4ce29
This diff is collapsed.
tests/run/embedsignatures.pyx
View file @ 44f4ce29
This diff is collapsed.
tests/run/typedfieldbug_T303.pyx
View file @ 44f4ce29
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7