def generate_native_getters_and_setters(cl: ClassIR, emitter: Emitter) -> None:
for attr, rtype in cl.attributes.items():
# Native getter
emitter.emit_line('{}{}({} *self)'.format(
emitter.ctype_spaced(rtype),
native_getter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names)))
emitter.emit_line('{')
if rtype.is_refcounted:
emit_undefined_check(rtype, emitter, attr, '==')
emitter.emit_lines(
'PyErr_SetString(PyExc_AttributeError, "attribute {} of {} undefined");'
.format(repr(attr), repr(cl.name)), '} else {')
emitter.emit_inc_ref('self->{}'.format(attr), rtype)
emitter.emit_line('}')
emitter.emit_line('return self->{};'.format(attr))
emitter.emit_line('}')
emitter.emit_line()
# Native setter
emitter.emit_line('bool {}({} *self, {}value)'.format(
native_setter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names), emitter.ctype_spaced(rtype)))
emitter.emit_line('{')
if rtype.is_refcounted:
emit_undefined_check(rtype, emitter, attr, '!=')
emitter.emit_dec_ref('self->{}'.format(attr), rtype)
emitter.emit_line('}')
# This steal the reference to src, so we don't need to increment the arg
emitter.emit_lines('self->{} = value;'.format(attr), 'return 1;', '}')
emitter.emit_line()
def generate_setup_for_class(cl: ClassIR, func_name: str,
defaults_fn: Optional[FuncIR], vtable_name: str,
emitter: Emitter) -> None:
"""Generate a native function that allocates an instance of a class."""
emitter.emit_line('static PyObject *')
emitter.emit_line('{}(void)'.format(func_name))
emitter.emit_line('{')
emitter.emit_line('{} *self;'.format(cl.struct_name(emitter.names)))
emitter.emit_line(
'self = ({struct} *){type_struct}->tp_alloc({type_struct}, 0);'.format(
struct=cl.struct_name(emitter.names),
type_struct=emitter.type_struct_name(cl)))
emitter.emit_line('if (self == NULL)')
emitter.emit_line(' return NULL;')
emitter.emit_line('self->vtable = {};'.format(vtable_name))
for base in reversed(cl.base_mro):
for attr, rtype in base.attributes.items():
emitter.emit_line('self->{} = {};'.format(
attr, emitter.c_undefined_value(rtype)))
# Initialize attributes to default values, if necessary
if defaults_fn is not None:
emitter.emit_lines(
'if ({}{}((PyObject *)self) == 0) {{'.format(
NATIVE_PREFIX, defaults_fn.cname(emitter.names)),
'Py_DECREF(self);', 'return NULL;', '}')
emitter.emit_line('return (PyObject *)self;')
emitter.emit_line('}')
def generate_getseter_declarations(cl: ClassIR, emitter: Emitter) -> None:
if not cl.is_trait:
for attr in cl.attributes:
emitter.emit_line('static PyObject *')
emitter.emit_line('{}({} *self, void *closure);'.format(
getter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names)))
emitter.emit_line('static int')
emitter.emit_line(
'{}({} *self, PyObject *value, void *closure);'.format(
setter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names)))
for prop in cl.properties:
# Generate getter declaration
emitter.emit_line('static PyObject *')
emitter.emit_line('{}({} *self, void *closure);'.format(
getter_name(cl, prop, emitter.names),
cl.struct_name(emitter.names)))
# Generate property setter declaration if a setter exists
if cl.properties[prop][1]:
emitter.emit_line('static int')
emitter.emit_line(
'{}({} *self, PyObject *value, void *closure);'.format(
setter_name(cl, prop, emitter.names),
cl.struct_name(emitter.names)))
def declare_native_getters_and_setters(cl: ClassIR, emitter: Emitter) -> None:
for attr, rtype in cl.attributes.items():
emitter.emit_line('{}{}({} *self);'.format(
emitter.ctype_spaced(rtype),
native_getter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names)))
emitter.emit_line('bool {}({} *self, {}value);'.format(
native_setter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names), emitter.ctype_spaced(rtype)))
def generate_getseter_declarations(cl: ClassIR, emitter: Emitter) -> None:
for attr in cl.attributes:
emitter.emit_line('static PyObject *')
emitter.emit_line('{}({} *self, void *closure);'.format(
getter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names)))
emitter.emit_line('static int')
emitter.emit_line('{}({} *self, PyObject *value, void *closure);'.format(
setter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names)))
def generate_object_struct(cl: ClassIR, emitter: Emitter) -> None:
seen_attrs = set() # type: Set[Tuple[str, RType]]
lines = [] # type: List[str]
lines += ['typedef struct {', 'PyObject_HEAD', 'CPyVTableItem *vtable;']
for base in reversed(cl.base_mro):
if not base.is_trait:
for attr, rtype in base.attributes.items():
if (attr, rtype) not in seen_attrs:
lines.append('{}{};'.format(emitter.ctype_spaced(rtype),
emitter.attr(attr)))
seen_attrs.add((attr, rtype))
lines.append('}} {};'.format(cl.struct_name(emitter.names)))
lines.append('')
emitter.context.declarations[cl.struct_name(
emitter.names)] = HeaderDeclaration(lines, is_type=True)
def declare_native_getters_and_setters(cl: ClassIR, emitter: Emitter) -> None:
decls = emitter.context.declarations
for attr, rtype in cl.attributes.items():
getter_name = native_getter_name(cl, attr, emitter.names)
setter_name = native_setter_name(cl, attr, emitter.names)
decls[getter_name] = HeaderDeclaration(
'{}{}({} *self);'.format(emitter.ctype_spaced(rtype), getter_name,
cl.struct_name(emitter.names)),
needs_export=True,
)
decls[setter_name] = HeaderDeclaration(
'bool {}({} *self, {}value);'.format(
native_setter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names), emitter.ctype_spaced(rtype)),
needs_export=True,
)
def generate_setter(cl: ClassIR, attr: str, rtype: RType,
emitter: Emitter) -> None:
emitter.emit_line('static int')
emitter.emit_line('{}({} *self, PyObject *value, void *closure)'.format(
setter_name(cl, attr, emitter.names), cl.struct_name(emitter.names)))
emitter.emit_line('{')
if rtype.is_refcounted:
emit_undefined_check(rtype, emitter, attr, '!=')
emitter.emit_dec_ref('self->{}'.format(attr), rtype)
emitter.emit_line('}')
emitter.emit_line('if (value != NULL) {')
if rtype.is_unboxed:
emitter.emit_unbox('value',
'tmp',
rtype,
custom_failure='return -1;',
declare_dest=True)
elif is_same_type(rtype, object_rprimitive):
emitter.emit_line('PyObject *tmp = value;')
else:
emitter.emit_cast('value', 'tmp', rtype, declare_dest=True)
emitter.emit_lines('if (!tmp)', ' return -1;')
emitter.emit_inc_ref('tmp', rtype)
emitter.emit_line('self->{} = tmp;'.format(attr))
emitter.emit_line('} else')
emitter.emit_line(' self->{} = {};'.format(
attr, emitter.c_undefined_value(rtype)))
emitter.emit_line('return 0;')
emitter.emit_line('}')
def generate_object_struct(cl: ClassIR, emitter: Emitter) -> None:
emitter.emit_lines('typedef struct {', 'PyObject_HEAD',
'CPyVTableItem *vtable;')
for base in reversed(cl.base_mro):
if not base.is_trait:
for attr, rtype in base.attributes.items():
emitter.emit_line('{}{};'.format(emitter.ctype_spaced(rtype),
attr))
emitter.emit_line('}} {};'.format(cl.struct_name(emitter.names)))
def generate_dealloc_for_class(cl: ClassIR, dealloc_func_name: str,
clear_func_name: str, emitter: Emitter) -> None:
emitter.emit_line('static void')
emitter.emit_line('{}({} *self)'.format(dealloc_func_name,
cl.struct_name(emitter.names)))
emitter.emit_line('{')
emitter.emit_line('PyObject_GC_UnTrack(self);')
emitter.emit_line('{}(self);'.format(clear_func_name))
emitter.emit_line('Py_TYPE(self)->tp_free((PyObject *)self);')
emitter.emit_line('}')
def generate_clear_for_class(cl: ClassIR, func_name: str,
emitter: Emitter) -> None:
emitter.emit_line('static int')
emitter.emit_line('{}({} *self)'.format(func_name,
cl.struct_name(emitter.names)))
emitter.emit_line('{')
for base in reversed(cl.base_mro):
for attr, rtype in base.attributes.items():
emitter.emit_gc_clear('self->{}'.format(attr), rtype)
emitter.emit_line('return 0;')
emitter.emit_line('}')
def generate_setup_for_class(cl: ClassIR,
func_name: str,
vtable_name: str,
emitter: Emitter) -> None:
"""Generate a native function that allocates an instance of a class."""
emitter.emit_line('static PyObject *')
emitter.emit_line('{}(void)'.format(func_name))
emitter.emit_line('{')
emitter.emit_line('{} *self;'.format(cl.struct_name(emitter.names)))
emitter.emit_line('self = ({struct} *){type_struct}.tp_alloc(&{type_struct}, 0);'.format(
struct=cl.struct_name(emitter.names),
type_struct=emitter.type_struct_name(cl)))
emitter.emit_line('if (self == NULL)')
emitter.emit_line(' return NULL;')
emitter.emit_line('self->vtable = {};'.format(vtable_name))
for base in reversed(cl.base_mro):
for attr, rtype in base.attributes.items():
emitter.emit_line('self->{} = {};'.format(attr, emitter.c_undefined_value(rtype)))
emitter.emit_line('return (PyObject *)self;')
emitter.emit_line('}')
def generate_clear_for_class(cl: ClassIR, func_name: str,
emitter: Emitter) -> None:
emitter.emit_line('static int')
emitter.emit_line('{}({} *self)'.format(func_name,
cl.struct_name(emitter.names)))
emitter.emit_line('{')
for base in reversed(cl.base_mro):
for attr, rtype in base.attributes.items():
emitter.emit_gc_clear('self->{}'.format(emitter.attr(attr)), rtype)
if cl.has_dict:
struct_name = cl.struct_name(emitter.names)
# __dict__ lives right after the struct and __weakref__ lives right after that
emitter.emit_gc_clear(
'*((PyObject **)((char *)self + sizeof({})))'.format(struct_name),
object_rprimitive)
emitter.emit_gc_clear(
'*((PyObject **)((char *)self + sizeof(PyObject *) + sizeof({})))'.
format(struct_name), object_rprimitive)
emitter.emit_line('return 0;')
emitter.emit_line('}')
def generate_traverse_for_class(cl: ClassIR, func_name: str,
emitter: Emitter) -> None:
"""Emit function that performs cycle GC traversal of an instance."""
emitter.emit_line('static int')
emitter.emit_line('{}({} *self, visitproc visit, void *arg)'.format(
func_name, cl.struct_name(emitter.names)))
emitter.emit_line('{')
for base in reversed(cl.base_mro):
for attr, rtype in base.attributes.items():
emitter.emit_gc_visit('self->{}'.format(emitter.attr(attr)), rtype)
if cl.has_dict:
struct_name = cl.struct_name(emitter.names)
# __dict__ lives right after the struct and __weakref__ lives right after that
emitter.emit_gc_visit(
'*((PyObject **)((char *)self + sizeof({})))'.format(struct_name),
object_rprimitive)
emitter.emit_gc_visit(
'*((PyObject **)((char *)self + sizeof(PyObject *) + sizeof({})))'.
format(struct_name), object_rprimitive)
emitter.emit_line('return 0;')
emitter.emit_line('}')
def generate_object_struct(cl: ClassIR, emitter: Emitter) -> None:
emitter.emit_lines('typedef struct {', 'PyObject_HEAD',
'CPyVTableItem *vtable;')
seen_attrs = set() # type: Set[Tuple[str, RType]]
for base in reversed(cl.base_mro):
if not base.is_trait:
for attr, rtype in base.attributes.items():
if (attr, rtype) not in seen_attrs:
emitter.emit_line('{}{};'.format(
emitter.ctype_spaced(rtype), emitter.attr(attr)))
seen_attrs.add((attr, rtype))
emitter.emit_line('}} {};'.format(cl.struct_name(emitter.names)))
def generate_traverse_for_class(cl: ClassIR, func_name: str,
emitter: Emitter) -> None:
"""Emit function that performs cycle GC traversal of an instance."""
emitter.emit_line('static int')
emitter.emit_line('{}({} *self, visitproc visit, void *arg)'.format(
func_name, cl.struct_name(emitter.names)))
emitter.emit_line('{')
for base in reversed(cl.base_mro):
for attr, rtype in base.attributes.items():
emitter.emit_gc_visit('self->{}'.format(attr), rtype)
emitter.emit_line('return 0;')
emitter.emit_line('}')
def generate_native_getters_and_setters(cl: ClassIR,
emitter: Emitter) -> None:
for attr, rtype in cl.attributes.items():
# Native getter
emitter.emit_line('{}{}({} *self)'.format(emitter.ctype_spaced(rtype),
native_getter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names)))
emitter.emit_line('{')
if rtype.is_refcounted:
emitter.emit_lines(
'if (self->{} == {}) {{'.format(attr, emitter.c_undefined_value(rtype)),
'PyErr_SetString(PyExc_AttributeError, "attribute {} of {} undefined");'.format(
repr(attr), repr(cl.name)),
'} else {')
emitter.emit_inc_ref('self->{}'.format(attr), rtype)
emitter.emit_line('}')
emitter.emit_line('return self->{};'.format(attr))
emitter.emit_line('}')
emitter.emit_line()
# Native setter
emitter.emit_line(
'bool {}({} *self, {}value)'.format(native_setter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names),
emitter.ctype_spaced(rtype)))
emitter.emit_line('{')
if rtype.is_refcounted:
emitter.emit_line('if (self->{} != {}) {{'.format(attr,
emitter.c_undefined_value(rtype)))
emitter.emit_dec_ref('self->{}'.format(attr), rtype)
emitter.emit_line('}')
emitter.emit_inc_ref('value'.format(attr), rtype)
emitter.emit_lines('self->{} = value;'.format(attr),
'return 1;',
'}')
emitter.emit_line()
def generate_readonly_getter(cl: ClassIR, attr: str, rtype: RType,
func_ir: FuncIR, emitter: Emitter) -> None:
emitter.emit_line('static PyObject *')
emitter.emit_line('{}({} *self, void *closure)'.format(
getter_name(cl, attr, emitter.names), cl.struct_name(emitter.names)))
emitter.emit_line('{')
if rtype.is_unboxed:
emitter.emit_line('{}retval = {}{}((PyObject *) self);'.format(
emitter.ctype_spaced(rtype), NATIVE_PREFIX,
func_ir.cname(emitter.names)))
emitter.emit_box('retval', 'retbox', rtype, declare_dest=True)
emitter.emit_line('return retbox;')
else:
emitter.emit_line('return {}{}((PyObject *) self);'.format(
NATIVE_PREFIX, func_ir.cname(emitter.names)))
emitter.emit_line('}')
def generate_getter(cl: ClassIR,
attr: str,
rtype: RType,
emitter: Emitter) -> None:
emitter.emit_line('static PyObject *')
emitter.emit_line('{}({} *self, void *closure)'.format(getter_name(cl, attr, emitter.names),
cl.struct_name(emitter.names)))
emitter.emit_line('{')
emitter.emit_line('if (self->{} == {}) {{'.format(attr, emitter.c_undefined_value(rtype)))
emitter.emit_line('PyErr_SetString(PyExc_AttributeError,')
emitter.emit_line(' "attribute {} of {} undefined");'.format(repr(attr),
repr(cl.name)))
emitter.emit_line('return NULL;')
emitter.emit_line('}')
emitter.emit_inc_ref('self->{}'.format(attr), rtype)
emitter.emit_box('self->{}'.format(attr), 'retval', rtype, declare_dest=True)
emitter.emit_line('return retval;')
emitter.emit_line('}')
def generate_property_setter(cl: ClassIR, attr: str, arg_type: RType,
func_ir: FuncIR, emitter: Emitter) -> None:
emitter.emit_line('static int')
emitter.emit_line('{}({} *self, PyObject *value, void *closure)'.format(
setter_name(cl, attr, emitter.names), cl.struct_name(emitter.names)))
emitter.emit_line('{')
if arg_type.is_unboxed:
emitter.emit_unbox('value',
'tmp',
arg_type,
custom_failure='return -1;',
declare_dest=True)
emitter.emit_line('{}{}((PyObject *) self, tmp);'.format(
NATIVE_PREFIX, func_ir.cname(emitter.names)))
else:
emitter.emit_line('{}{}((PyObject *) self, value);'.format(
NATIVE_PREFIX, func_ir.cname(emitter.names)))
emitter.emit_line('return 0;')
emitter.emit_line('}')
def generate_class(cl: ClassIR, module: str, emitter: Emitter) -> None:
"""Generate C code for a class.
This is the main entry point to the module.
"""
name = cl.name
name_prefix = cl.name_prefix(emitter.names)
setup_name = '{}_setup'.format(name_prefix)
new_name = '{}_new'.format(name_prefix)
getseters_name = '{}_getseters'.format(name_prefix)
vtable_name = '{}_vtable'.format(name_prefix)
traverse_name = '{}_traverse'.format(name_prefix)
clear_name = '{}_clear'.format(name_prefix)
dealloc_name = '{}_dealloc'.format(name_prefix)
methods_name = '{}_methods'.format(name_prefix)
vtable_setup_name = '{}_trait_vtable_setup'.format(name_prefix)
fields = OrderedDict() # type: Dict[str, str]
fields['tp_name'] = '"{}"'.format(name)
generate_full = not cl.is_trait and not cl.builtin_base
needs_getseters = not cl.is_generated
if generate_full:
fields['tp_new'] = new_name
fields['tp_dealloc'] = '(destructor){}_dealloc'.format(name_prefix)
fields['tp_traverse'] = '(traverseproc){}_traverse'.format(name_prefix)
fields['tp_clear'] = '(inquiry){}_clear'.format(name_prefix)
if needs_getseters:
fields['tp_getset'] = getseters_name
fields['tp_methods'] = methods_name
def emit_line() -> None:
emitter.emit_line()
emit_line()
generate_object_struct(cl, emitter)
emit_line()
# If the class has a method to initialize default attribute
# values, we need to call it during initialization.
defaults_fn = cl.get_method('__mypyc_defaults_setup')
# If there is a __init__ method, we'll use it in the native constructor.
init_fn = cl.get_method('__init__')
# Fill out slots in the type object from dunder methods.
fields.update(generate_slots(cl, SLOT_DEFS, emitter))
# Fill out dunder methods that live in tables hanging off the side.
for table_name, type, slot_defs in SIDE_TABLES:
slots = generate_slots(cl, slot_defs, emitter)
if slots:
table_struct_name = generate_side_table_for_class(
cl, table_name, type, slots, emitter)
fields['tp_{}'.format(table_name)] = '&{}'.format(
table_struct_name)
richcompare_name = generate_richcompare_wrapper(cl, emitter)
if richcompare_name:
fields['tp_richcompare'] = richcompare_name
# If the class inherits from python, make space for a __dict__
struct_name = cl.struct_name(emitter.names)
if cl.builtin_base:
base_size = 'sizeof({})'.format(cl.builtin_base)
elif cl.is_trait:
base_size = 'sizeof(PyObject)'
else:
base_size = 'sizeof({})'.format(struct_name)
# Since our types aren't allocated using type() we need to
# populate these fields ourselves if we want them to have correct
# values. PyType_Ready will inherit the offsets from tp_base but
# that isn't what we want.
if any(x.inherits_python for x in cl.mro):
fields['tp_basicsize'] = '{} + 2*sizeof(PyObject *)'.format(base_size)
fields['tp_dictoffset'] = base_size
fields['tp_weaklistoffset'] = '{} + sizeof(PyObject *)'.format(
base_size)
else:
fields['tp_basicsize'] = base_size
if generate_full:
emitter.emit_line('static PyObject *{}(void);'.format(setup_name))
assert cl.ctor is not None
emitter.emit_line(native_function_header(cl.ctor, emitter) + ';')
emit_line()
generate_new_for_class(cl, new_name, vtable_name, setup_name, emitter)
emit_line()
generate_traverse_for_class(cl, traverse_name, emitter)
emit_line()
generate_clear_for_class(cl, clear_name, emitter)
emit_line()
generate_dealloc_for_class(cl, dealloc_name, clear_name, emitter)
emit_line()
generate_native_getters_and_setters(cl, emitter)
vtable_name = generate_vtables(cl, vtable_name, emitter)
emit_line()
if needs_getseters:
generate_getseter_declarations(cl, emitter)
emit_line()
generate_getseters_table(cl, getseters_name, emitter)
emit_line()
generate_methods_table(cl, methods_name, emitter)
emit_line()
flags = [
'Py_TPFLAGS_DEFAULT', 'Py_TPFLAGS_HEAPTYPE', 'Py_TPFLAGS_BASETYPE'
]
if generate_full:
flags.append('Py_TPFLAGS_HAVE_GC')
fields['tp_flags'] = ' | '.join(flags)
emitter.emit_line("static PyTypeObject {}_template_ = {{".format(
emitter.type_struct_name(cl)))
emitter.emit_line("PyVarObject_HEAD_INIT(&PyType_Type, 0)")
for field, value in fields.items():
emitter.emit_line(".{} = {},".format(field, value))
emitter.emit_line("};")
emitter.emit_line(
"static PyTypeObject *{t}_template = &{t}_template_;".format(
t=emitter.type_struct_name(cl)))
emitter.emit_line()
generate_trait_vtable_setup(cl, vtable_setup_name, vtable_name, emitter)
if generate_full:
generate_setup_for_class(cl, setup_name, defaults_fn, vtable_name,
emitter)
emitter.emit_line()
generate_constructor_for_class(cl, cl.ctor, init_fn, setup_name,
vtable_name, emitter)
emitter.emit_line()
if needs_getseters:
generate_getseters(cl, emitter)
def generate_class(cl: ClassIR, module: str, emitter: Emitter) -> None:
"""Generate C code for a class.
This is the main entry point to the module.
"""
name = cl.name
name_prefix = cl.name_prefix(emitter.names)
fullname = '{}.{}'.format(module, name)
setup_name = new_name = clear_name = dealloc_name = '0'
traverse_name = getseters_name = vtable_name = '0'
if not cl.is_trait:
setup_name = '{}_setup'.format(name_prefix)
new_name = '{}_new'.format(name_prefix)
traverse_name = '{}_traverse'.format(name_prefix)
clear_name = '{}_clear'.format(name_prefix)
dealloc_name = '{}_dealloc'.format(name_prefix)
getseters_name = '{}_getseters'.format(name_prefix)
vtable_name = '{}_vtable'.format(name_prefix)
methods_name = '{}_methods'.format(name_prefix)
base_arg = "&{}".format(
emitter.type_struct_name(cl.base)) if cl.base and not cl.traits else "0"
def emit_line() -> None:
emitter.emit_line()
emit_line()
generate_object_struct(cl, emitter)
emit_line()
# If there is a __init__ method, generate a function for tp_init and
# extract the args (which we'll use for the native constructor)
init_fn = cl.get_method('__init__')
if init_fn:
init_name = '{}_init'.format(name_prefix)
init_args = init_fn.args[1:]
generate_init_for_class(cl, init_name, init_fn, emitter)
else:
init_name = '0'
init_args = []
call_fn = cl.get_method('__call__')
call_name = '{}{}'.format(PREFIX, call_fn.cname(emitter.names)) if call_fn else '0'
if not cl.is_trait:
emitter.emit_line('static PyObject *{}(void);'.format(setup_name))
# TODO: Use RInstance
ctor = FuncIR(cl.name, None, module, FuncSignature(init_args, object_rprimitive),
[], Environment())
emitter.emit_line(native_function_header(ctor, emitter) + ';')
emit_line()
generate_new_for_class(cl, new_name, vtable_name, setup_name, emitter)
emit_line()
generate_traverse_for_class(cl, traverse_name, emitter)
emit_line()
generate_clear_for_class(cl, clear_name, emitter)
emit_line()
generate_dealloc_for_class(cl, dealloc_name, clear_name, emitter)
emit_line()
generate_native_getters_and_setters(cl, emitter)
vtable_name = generate_vtables(cl, vtable_name, emitter)
emit_line()
generate_getseter_declarations(cl, emitter)
emit_line()
generate_getseters_table(cl, getseters_name, emitter)
emit_line()
generate_methods_table(cl, methods_name, emitter)
emit_line()
emitter.emit_line(textwrap.dedent("""\
static PyTypeObject {type_struct} = {{
PyVarObject_HEAD_INIT(NULL, 0)
"{fullname}", /* tp_name */
sizeof({struct_name}), /* tp_basicsize */
0, /* tp_itemsize */
(destructor){dealloc_name}, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
{tp_call}, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
0, /* tp_doc */
(traverseproc){traverse_name}, /* tp_traverse */
(inquiry){clear_name}, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
{methods_name}, /* tp_methods */
0, /* tp_members */
{getseters_name}, /* tp_getset */
{base_arg}, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
{init_name}, /* tp_init */
0, /* tp_alloc */
{new_name}, /* tp_new */
}};\
""").format(type_struct=emitter.type_struct_name(cl),
struct_name=cl.struct_name(emitter.names),
fullname=fullname,
traverse_name=traverse_name,
clear_name=clear_name,
dealloc_name=dealloc_name,
tp_call=call_name,
new_name=new_name,
methods_name=methods_name,
getseters_name=getseters_name,
init_name=init_name,
base_arg=base_arg,
))
emitter.emit_line()
if not cl.is_trait:
generate_setup_for_class(cl, setup_name, vtable_name, emitter)
emitter.emit_line()
generate_constructor_for_class(cl, ctor, init_fn, setup_name, vtable_name, emitter)
emitter.emit_line()
generate_getseters(cl, emitter)
def generate_class(cl: ClassIR, module: str, emitter: Emitter) -> None:
"""Generate C code for a class.
This is the main entry point to the module.
"""
name = cl.name
name_prefix = cl.name_prefix(emitter.names)
setup_name = '{}_setup'.format(name_prefix)
new_name = '{}_new'.format(name_prefix)
members_name = '{}_members'.format(name_prefix)
getseters_name = '{}_getseters'.format(name_prefix)
vtable_name = '{}_vtable'.format(name_prefix)
traverse_name = '{}_traverse'.format(name_prefix)
clear_name = '{}_clear'.format(name_prefix)
dealloc_name = '{}_dealloc'.format(name_prefix)
methods_name = '{}_methods'.format(name_prefix)
vtable_setup_name = '{}_trait_vtable_setup'.format(name_prefix)
fields = OrderedDict() # type: Dict[str, str]
fields['tp_name'] = '"{}"'.format(name)
generate_full = not cl.is_trait and not cl.builtin_base
needs_getseters = not cl.is_generated
if generate_full:
fields['tp_new'] = new_name
fields['tp_dealloc'] = '(destructor){}_dealloc'.format(name_prefix)
fields['tp_traverse'] = '(traverseproc){}_traverse'.format(name_prefix)
fields['tp_clear'] = '(inquiry){}_clear'.format(name_prefix)
if needs_getseters:
fields['tp_getset'] = getseters_name
fields['tp_methods'] = methods_name
def emit_line() -> None:
emitter.emit_line()
emit_line()
# If the class has a method to initialize default attribute
# values, we need to call it during initialization.
defaults_fn = cl.get_method('__mypyc_defaults_setup')
# If there is a __init__ method, we'll use it in the native constructor.
init_fn = cl.get_method('__init__')
# Fill out slots in the type object from dunder methods.
fields.update(generate_slots(cl, SLOT_DEFS, emitter))
# Fill out dunder methods that live in tables hanging off the side.
for table_name, type, slot_defs in SIDE_TABLES:
slots = generate_slots(cl, slot_defs, emitter)
if slots:
table_struct_name = generate_side_table_for_class(
cl, table_name, type, slots, emitter)
fields['tp_{}'.format(table_name)] = '&{}'.format(
table_struct_name)
richcompare_name = generate_richcompare_wrapper(cl, emitter)
if richcompare_name:
fields['tp_richcompare'] = richcompare_name
# If the class inherits from python, make space for a __dict__
struct_name = cl.struct_name(emitter.names)
if cl.builtin_base:
base_size = 'sizeof({})'.format(cl.builtin_base)
elif cl.is_trait:
base_size = 'sizeof(PyObject)'
else:
base_size = 'sizeof({})'.format(struct_name)
# Since our types aren't allocated using type() we need to
# populate these fields ourselves if we want them to have correct
# values. PyType_Ready will inherit the offsets from tp_base but
# that isn't what we want.
# XXX: there is no reason for the __weakref__ stuff to be mixed up with __dict__
if cl.has_dict:
# __dict__ lives right after the struct and __weakref__ lives right after that
# TODO: They should get members in the struct instead of doing this nonsense.
weak_offset = '{} + sizeof(PyObject *)'.format(base_size)
emitter.emit_lines(
'PyMemberDef {}[] = {{'.format(members_name),
'{{"__dict__", T_OBJECT_EX, {}, 0, NULL}},'.format(base_size),
'{{"__weakref__", T_OBJECT_EX, {}, 0, NULL}},'.format(weak_offset),
'{0}',
'};',
)
fields['tp_members'] = members_name
fields['tp_basicsize'] = '{} + 2*sizeof(PyObject *)'.format(base_size)
fields['tp_dictoffset'] = base_size
fields['tp_weaklistoffset'] = weak_offset
else:
fields['tp_basicsize'] = base_size
if generate_full:
# Declare setup method that allocates and initializes an object. type is the
# type of the class being initialized, which could be another class if there
# is an interpreted subclass.
emitter.emit_line(
'static PyObject *{}(PyTypeObject *type);'.format(setup_name))
assert cl.ctor is not None
emitter.emit_line(native_function_header(cl.ctor, emitter) + ';')
emit_line()
generate_new_for_class(cl, new_name, vtable_name, setup_name, emitter)
emit_line()
generate_traverse_for_class(cl, traverse_name, emitter)
emit_line()
generate_clear_for_class(cl, clear_name, emitter)
emit_line()
generate_dealloc_for_class(cl, dealloc_name, clear_name, emitter)
emit_line()
generate_native_getters_and_setters(cl, emitter)
if cl.allow_interpreted_subclasses:
shadow_vtable_name = generate_vtables(
cl,
vtable_setup_name + "_shadow",
vtable_name + "_shadow",
emitter,
shadow=True) # type: Optional[str]
emit_line()
else:
shadow_vtable_name = None
vtable_name = generate_vtables(cl,
vtable_setup_name,
vtable_name,
emitter,
shadow=False)
emit_line()
if needs_getseters:
generate_getseter_declarations(cl, emitter)
emit_line()
generate_getseters_table(cl, getseters_name, emitter)
emit_line()
generate_methods_table(cl, methods_name, emitter)
emit_line()
flags = [
'Py_TPFLAGS_DEFAULT', 'Py_TPFLAGS_HEAPTYPE', 'Py_TPFLAGS_BASETYPE'
]
if generate_full:
flags.append('Py_TPFLAGS_HAVE_GC')
fields['tp_flags'] = ' | '.join(flags)
emitter.emit_line("static PyTypeObject {}_template_ = {{".format(
emitter.type_struct_name(cl)))
emitter.emit_line("PyVarObject_HEAD_INIT(NULL, 0)")
for field, value in fields.items():
emitter.emit_line(".{} = {},".format(field, value))
emitter.emit_line("};")
emitter.emit_line(
"static PyTypeObject *{t}_template = &{t}_template_;".format(
t=emitter.type_struct_name(cl)))
emitter.emit_line()
if generate_full:
generate_setup_for_class(cl, setup_name, defaults_fn, vtable_name,
shadow_vtable_name, emitter)
emitter.emit_line()
generate_constructor_for_class(cl, cl.ctor, init_fn, setup_name,
vtable_name, emitter)
emitter.emit_line()
if needs_getseters:
generate_getseters(cl, emitter)