Commit 20326322 authored by Robert Bradshaw's avatar Robert Bradshaw Committed by GitHub

Merge pull request #1927 from robertwb/multi-inheritance

Multiple inheritance
parents 59d95f6d edbd9db3
...@@ -8,6 +8,10 @@ Cython Changelog ...@@ -8,6 +8,10 @@ Cython Changelog
Features added Features added
-------------- --------------
* Cdef classes can now multiply inherit from ordinary Python classes.
(The primary base must still be a c class, possibly ``object``, and
the other bases must *not* be cdef classes.)
* Type inference is now supported for Pythran compiled NumPy expressions. * Type inference is now supported for Pythran compiled NumPy expressions.
Patch by Nils Braun. (Github issue #1954) Patch by Nils Braun. (Github issue #1954)
......
...@@ -2948,8 +2948,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): ...@@ -2948,8 +2948,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
else: else:
self.generate_base_type_import_code(env, entry, code) self.generate_base_type_import_code(env, entry, code)
self.generate_exttype_vtable_init_code(entry, code) self.generate_exttype_vtable_init_code(entry, code)
self.generate_type_ready_code(env, entry, code) if entry.type.early_init:
self.generate_typeptr_assignment_code(entry, code) self.generate_type_ready_code(entry, code)
def generate_base_type_import_code(self, env, entry, code): def generate_base_type_import_code(self, env, entry, code):
base_type = entry.type.base_type base_type = entry.type.base_type
...@@ -3023,98 +3023,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): ...@@ -3023,98 +3023,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
not type.is_external or type.is_subclassed, not type.is_external or type.is_subclassed,
error_code)) error_code))
def generate_type_ready_code(self, env, entry, code): def generate_type_ready_code(self, entry, code):
# Generate a call to PyType_Ready for an extension Nodes.CClassDefNode.generate_type_ready_code(entry, code)
# type defined in this module.
type = entry.type
typeobj_cname = type.typeobj_cname
scope = type.scope
if scope: # could be None if there was an error
if entry.visibility != 'extern':
for slot in TypeSlots.slot_table:
slot.generate_dynamic_init_code(scope, code)
code.putln(
"if (PyType_Ready(&%s) < 0) %s" % (
typeobj_cname,
code.error_goto(entry.pos)))
# Don't inherit tp_print from builtin types, restoring the
# behavior of using tp_repr or tp_str instead.
code.putln("%s.tp_print = 0;" % typeobj_cname)
# Fix special method docstrings. This is a bit of a hack, but
# unless we let PyType_Ready create the slot wrappers we have
# a significant performance hit. (See trac #561.)
for func in entry.type.scope.pyfunc_entries:
is_buffer = func.name in ('__getbuffer__', '__releasebuffer__')
if (func.is_special and Options.docstrings and
func.wrapperbase_cname and not is_buffer):
slot = TypeSlots.method_name_to_slot[func.name]
preprocessor_guard = slot.preprocessor_guard_code()
if preprocessor_guard:
code.putln(preprocessor_guard)
code.putln('#if CYTHON_COMPILING_IN_CPYTHON')
code.putln("{")
code.putln(
'PyObject *wrapper = PyObject_GetAttrString((PyObject *)&%s, "%s"); %s' % (
typeobj_cname,
func.name,
code.error_goto_if_null('wrapper', entry.pos)))
code.putln(
"if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {")
code.putln(
"%s = *((PyWrapperDescrObject *)wrapper)->d_base;" % (
func.wrapperbase_cname))
code.putln(
"%s.doc = %s;" % (func.wrapperbase_cname, func.doc_cname))
code.putln(
"((PyWrapperDescrObject *)wrapper)->d_base = &%s;" % (
func.wrapperbase_cname))
code.putln("}")
code.putln("}")
code.putln('#endif')
if preprocessor_guard:
code.putln('#endif')
if type.vtable_cname:
code.putln(
"if (__Pyx_SetVtable(%s.tp_dict, %s) < 0) %s" % (
typeobj_cname,
type.vtabptr_cname,
code.error_goto(entry.pos)))
code.globalstate.use_utility_code(
UtilityCode.load_cached('SetVTable', 'ImportExport.c'))
if not type.scope.is_internal and not type.scope.directives['internal']:
# scope.is_internal is set for types defined by
# Cython (such as closures), the 'internal'
# directive is set by users
code.putln(
'if (PyObject_SetAttrString(%s, "%s", (PyObject *)&%s) < 0) %s' % (
Naming.module_cname,
scope.class_name,
typeobj_cname,
code.error_goto(entry.pos)))
weakref_entry = scope.lookup_here("__weakref__") if not scope.is_closure_class_scope else None
if weakref_entry:
if weakref_entry.type is py_object_type:
tp_weaklistoffset = "%s.tp_weaklistoffset" % typeobj_cname
if type.typedef_flag:
objstruct = type.objstruct_cname
else:
objstruct = "struct %s" % type.objstruct_cname
code.putln("if (%s == 0) %s = offsetof(%s, %s);" % (
tp_weaklistoffset,
tp_weaklistoffset,
objstruct,
weakref_entry.cname))
else:
error(weakref_entry.pos, "__weakref__ slot must be of type 'object'")
if scope.lookup_here("__reduce_cython__") if not scope.is_closure_class_scope else None:
# Unfortunately, we cannot reliably detect whether a
# superclass defined __reduce__ at compile time, so we must
# do so at runtime.
code.globalstate.use_utility_code(
UtilityCode.load_cached('SetupReduce', 'ExtensionTypes.c'))
code.putln('if (__Pyx_setup_reduce((PyObject*)&%s) < 0) %s' % (
typeobj_cname,
code.error_goto(entry.pos)))
def generate_exttype_vtable_init_code(self, entry, code): def generate_exttype_vtable_init_code(self, entry, code):
# Generate code to initialise the C method table of an # Generate code to initialise the C method table of an
...@@ -3145,15 +3055,6 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): ...@@ -3145,15 +3055,6 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
cast, cast,
meth_entry.func_cname)) meth_entry.func_cname))
def generate_typeptr_assignment_code(self, entry, code):
# Generate code to initialise the typeptr of an extension
# type defined in this module to point to its type object.
type = entry.type
if type.typeobj_cname:
code.putln(
"%s = &%s;" % (
type.typeptr_cname, type.typeobj_cname))
def generate_cfunction_declaration(entry, env, code, definition): def generate_cfunction_declaration(entry, env, code, definition):
from_cy_utility = entry.used and entry.utility_code_definition from_cy_utility = entry.used and entry.utility_code_definition
if entry.used and entry.inline_func_in_pxd or (not entry.in_cinclude and ( if entry.used and entry.inline_func_in_pxd or (not entry.in_cinclude and (
......
This diff is collapsed.
...@@ -3435,19 +3435,15 @@ def p_c_class_definition(s, pos, ctx): ...@@ -3435,19 +3435,15 @@ def p_c_class_definition(s, pos, ctx):
as_name = class_name as_name = class_name
objstruct_name = None objstruct_name = None
typeobj_name = None typeobj_name = None
base_class_module = None bases = None
base_class_name = None
if s.sy == '(': if s.sy == '(':
s.next() positional_args, keyword_args = p_call_parse_args(s, allow_genexp=False)
base_class_path = [p_ident(s)] if keyword_args:
while s.sy == '.': s.error("C classes cannot take keyword bases.")
s.next() bases, _ = p_call_build_packed_args(pos, positional_args, keyword_args)
base_class_path.append(p_ident(s)) if bases is None:
if s.sy == ',': bases = ExprNodes.TupleNode(pos, args=[])
s.error("C class may only have one base class", fatal=False)
s.expect(')')
base_class_module = ".".join(base_class_path[:-1])
base_class_name = base_class_path[-1]
if s.sy == '[': if s.sy == '[':
if ctx.visibility not in ('public', 'extern') and not ctx.api: if ctx.visibility not in ('public', 'extern') and not ctx.api:
error(s.position(), "Name options only allowed for 'public', 'api', or 'extern' C class") error(s.position(), "Name options only allowed for 'public', 'api', or 'extern' C class")
...@@ -3487,8 +3483,7 @@ def p_c_class_definition(s, pos, ctx): ...@@ -3487,8 +3483,7 @@ def p_c_class_definition(s, pos, ctx):
module_name = ".".join(module_path), module_name = ".".join(module_path),
class_name = class_name, class_name = class_name,
as_name = as_name, as_name = as_name,
base_class_module = base_class_module, bases = bases,
base_class_name = base_class_name,
objstruct_name = objstruct_name, objstruct_name = objstruct_name,
typeobj_name = typeobj_name, typeobj_name = typeobj_name,
in_pxd = ctx.level == 'module_pxd', in_pxd = ctx.level == 'module_pxd',
......
...@@ -1302,10 +1302,12 @@ class PyExtensionType(PyObjectType): ...@@ -1302,10 +1302,12 @@ class PyExtensionType(PyObjectType):
# vtabstruct_cname string Name of C method table struct # vtabstruct_cname string Name of C method table struct
# vtabptr_cname string Name of pointer to C method table # vtabptr_cname string Name of pointer to C method table
# vtable_cname string Name of C method table definition # vtable_cname string Name of C method table definition
# early_init boolean Whether to initialize early (as opposed to during module execution).
# defered_declarations [thunk] Used to declare class hierarchies in order # defered_declarations [thunk] Used to declare class hierarchies in order
is_extension_type = 1 is_extension_type = 1
has_attributes = 1 has_attributes = 1
early_init = 1
objtypedef_cname = None objtypedef_cname = None
......
...@@ -656,6 +656,67 @@ bad: ...@@ -656,6 +656,67 @@ bad:
} }
/////////////// MergeVTables.proto ///////////////
//@requires: GetVTable
static int __Pyx_MergeVtables(PyTypeObject *type); /*proto*/
/////////////// MergeVTables ///////////////
static int __Pyx_MergeVtables(PyTypeObject *type) {
int i;
void** base_vtables;
void* unknown = (void*)-1;
PyObject* bases = type->tp_bases;
int base_depth = 0;
{
PyTypeObject* base = type->tp_base;
while (base) {
base_depth += 1;
base = base->tp_base;
}
}
base_vtables = (void**) malloc(sizeof(void*) * (base_depth + 1));
base_vtables[0] = unknown;
// Could do MRO resolution of individual methods in the future, assuming
// compatible vtables, but for now simply require a common vtable base.
// Note that if the vtables of various bases are extended separately,
// resolution isn't possible and we must reject it just as when the
// instance struct is so extended. (It would be good to also do this
// check when a multiple-base class is created in pure Python as well.)
for (i = 1; i < PyTuple_GET_SIZE(bases); i++) {
void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))->tp_dict);
if (base_vtable != NULL) {
int j;
PyTypeObject* base = type->tp_base;
for (j = 0; j < base_depth; j++) {
if (base_vtables[j] == unknown) {
base_vtables[j] = __Pyx_GetVtable(base->tp_dict);
base_vtables[j + 1] = unknown;
}
if (base_vtables[j] == base_vtable) {
break;
} else if (base_vtables[j] == NULL) {
// No more potential matching bases (with vtables).
goto bad;
}
base = base->tp_base;
}
}
}
PyErr_Clear();
free(base_vtables);
return 0;
bad:
PyErr_Format(
PyExc_TypeError,
"multiple bases have vtable conflict: '%s' and '%s'",
type->tp_base->tp_name, ((PyTypeObject*)PyTuple_GET_ITEM(bases, i))->tp_name);
free(base_vtables);
return -1;
}
/////////////// ImportNumPyArray.proto /////////////// /////////////// ImportNumPyArray.proto ///////////////
static PyObject *__pyx_numpy_ndarray = NULL; static PyObject *__pyx_numpy_ndarray = NULL;
......
...@@ -12,7 +12,7 @@ cdef class MyStr(str): # only in Py2, but can't know that during compilation ...@@ -12,7 +12,7 @@ cdef class MyStr(str): # only in Py2, but can't know that during compilation
pass pass
_ERRORS = """ _ERRORS = """
5:5: inheritance from PyVarObject types like 'tuple' is not currently supported 5:19: inheritance from PyVarObject types like 'tuple' is not currently supported
8:5: inheritance from PyVarObject types like 'bytes' is not currently supported 8:19: inheritance from PyVarObject types like 'bytes' is not currently supported
11:5: inheritance from PyVarObject types like 'str' is not currently supported 11:17: inheritance from PyVarObject types like 'str' is not currently supported
""" """
...@@ -10,5 +10,5 @@ cdef class SubType(FinalClass): ...@@ -10,5 +10,5 @@ cdef class SubType(FinalClass):
pass pass
_ERRORS = """ _ERRORS = """
9:5: Base class 'FinalClass' of type 'SubType' is final 9:19: Base class 'FinalClass' of type 'SubType' is final
""" """
cdef class CBase(object):
cdef int a
cdef c_method(self):
return "CBase"
cpdef cpdef_method(self):
return "CBase"
class PyBase(object):
def py_method(self):
return "PyBase"
cdef class Both(CBase, PyBase):
cdef dict __dict__
"""
>>> b = Both()
>>> b.py_method()
'PyBase'
>>> b.cp_method()
'Both'
>>> b.call_c_method()
'Both'
>>> isinstance(b, CBase)
True
>>> isinstance(b, PyBase)
True
"""
cdef c_method(self):
return "Both"
cpdef cp_method(self):
return "Both"
def call_c_method(self):
return self.c_method()
cdef class BothSub(Both):
"""
>>> b = BothSub()
>>> b.py_method()
'PyBase'
>>> b.cp_method()
'Both'
>>> b.call_c_method()
'Both'
"""
pass
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