def allocate_instance(self, cls, w_subtype):
"""Allocate the memory needed for an instance of an internal or
user-defined type, without actually __init__ializing the instance."""
w_type = self.gettypeobject(cls.typedef)
if self.is_w(w_type, w_subtype):
instance = instantiate(cls)
elif cls.typedef.acceptable_as_base_class:
# the purpose of the above check is to avoid the code below
# to be annotated at all for 'cls' if it is not necessary
w_subtype = w_type.check_user_subclass(w_subtype)
if cls.typedef.applevel_subclasses_base is not None:
cls = cls.typedef.applevel_subclasses_base
#
if (self.config.objspace.std.withmapdict and cls is W_ObjectObject
and not w_subtype.needsdel):
from pypy.objspace.std.mapdict import get_subclass_of_correct_size
subcls = get_subclass_of_correct_size(self, cls, w_subtype)
else:
subcls = get_unique_interplevel_subclass(
self.config, cls, w_subtype.hasdict,
w_subtype.layout.nslots != 0,
w_subtype.needsdel, w_subtype.weakrefable)
instance = instantiate(subcls)
assert isinstance(instance, cls)
instance.user_setup(self, w_subtype)
else:
raise oefmt(self.w_TypeError,
"%N.__new__(%N): only for the type %N",
w_type, w_subtype, w_type)
return instance
def allocate_instance(self, cls, w_subtype):
"""Allocate the memory needed for an instance of an internal or
user-defined type, without actually __init__ializing the instance."""
w_type = self.gettypeobject(cls.typedef)
if self.is_w(w_type, w_subtype):
instance = instantiate(cls)
elif cls.typedef.acceptable_as_base_class:
# the purpose of the above check is to avoid the code below
# to be annotated at all for 'cls' if it is not necessary
w_subtype = w_type.check_user_subclass(w_subtype)
if cls.typedef.applevel_subclasses_base is not None:
cls = cls.typedef.applevel_subclasses_base
#
if (self.config.objspace.std.withmapdict and cls is W_ObjectObject
and not w_subtype.needsdel):
from pypy.objspace.std.mapdict import get_subclass_of_correct_size
subcls = get_subclass_of_correct_size(self, cls, w_subtype)
else:
subcls = get_unique_interplevel_subclass(
self.config, cls, w_subtype.hasdict, w_subtype.nslots != 0,
w_subtype.needsdel, w_subtype.weakrefable)
instance = instantiate(subcls)
assert isinstance(instance, cls)
instance.user_setup(self, w_subtype)
else:
raise oefmt(self.w_TypeError,
"%N.__new__(%N): only for the type %N",
w_type, w_subtype, w_type)
return instance
def allocate_instance(self, cls, w_subtype):
"""Allocate the memory needed for an instance of an internal or
user-defined type, without actually __init__ializing the instance."""
w_type = self.gettypeobject(cls.typedef)
if self.is_w(w_type, w_subtype):
instance = instantiate(cls)
elif cls.typedef.acceptable_as_base_class:
# the purpose of the above check is to avoid the code below
# to be annotated at all for 'cls' if it is not necessary
w_subtype = w_type.check_user_subclass(w_subtype)
if cls.typedef.applevel_subclasses_base is not None:
cls = cls.typedef.applevel_subclasses_base
subcls = get_unique_interplevel_subclass(self.config, cls,
w_subtype.hasdict,
w_subtype.nslots != 0,
w_subtype.needsdel,
w_subtype.weakrefable)
instance = instantiate(subcls)
assert isinstance(instance, cls)
instance.user_setup(self, w_subtype)
else:
raise operationerrfmt(self.w_TypeError,
"%s.__new__(%s): only for the type %s",
w_type.name, w_subtype.getname(self, '?'),
w_type.name)
return instance
def allocate_instance(self, cls, w_subtype):
"""Allocate the memory needed for an instance of an internal or
user-defined type, without actually __init__ializing the instance."""
w_type = self.gettypeobject(cls.typedef)
if self.is_w(w_type, w_subtype):
instance = instantiate(cls)
elif cls.typedef.acceptable_as_base_class:
# the purpose of the above check is to avoid the code below
# to be annotated at all for 'cls' if it is not necessary
w_subtype = w_type.check_user_subclass(w_subtype)
subcls = get_unique_interplevel_subclass(cls, w_subtype.hasdict, w_subtype.nslots != 0, w_subtype.needsdel, w_subtype.weakrefable)
instance = instantiate(subcls)
instance.user_setup(self, w_subtype)
else:
raise OperationError(self.w_TypeError,
self.wrap("%s.__new__(%s): only for the type %s" % (
w_type.name, w_subtype.getname(self, '?'), w_type.name)))
assert isinstance(instance, cls)
return instance
def allocate_instance(self, cls, w_subtype):
"""Allocate the memory needed for an instance of an internal or
user-defined type, without actually __init__ializing the instance."""
w_type = self.gettypeobject(cls.typedef)
if self.is_w(w_type, w_subtype):
instance = instantiate(cls)
elif cls.typedef.acceptable_as_base_class:
# the purpose of the above check is to avoid the code below
# to be annotated at all for 'cls' if it is not necessary
w_subtype = w_type.check_user_subclass(w_subtype)
if cls.typedef.applevel_subclasses_base is not None:
cls = cls.typedef.applevel_subclasses_base
#
subcls = get_unique_interplevel_subclass(self, cls)
instance = instantiate(subcls)
assert isinstance(instance, cls)
instance.user_setup(self, w_subtype)
if w_subtype.hasuserdel:
self.finalizer_queue.register_finalizer(instance)
else:
raise oefmt(self.w_TypeError, "%N.__new__(%N): only for the type %N", w_type, w_subtype, w_type)
return instance
def allocate_instance(self, cls, w_subtype):
"""Allocate the memory needed for an instance of an internal or
user-defined type, without actually __init__ializing the instance."""
w_type = self.gettypeobject(cls.typedef)
if self.is_w(w_type, w_subtype):
instance = instantiate(cls)
elif cls.typedef.acceptable_as_base_class:
# the purpose of the above check is to avoid the code below
# to be annotated at all for 'cls' if it is not necessary
w_subtype = w_type.check_user_subclass(w_subtype)
if cls.typedef.applevel_subclasses_base is not None:
cls = cls.typedef.applevel_subclasses_base
#
if not we_are_translated():
if issubclass(cls, model.W_Object):
# If cls is missing from model.typeorder, then you
# need to add it there (including the inheritance
# relationship, if any)
assert cls in self.model.typeorder, repr(cls)
#
if (self.config.objspace.std.withmapdict and cls is W_ObjectObject
and not w_subtype.needsdel):
from pypy.objspace.std.mapdict import get_subclass_of_correct_size
subcls = get_subclass_of_correct_size(self, cls, w_subtype)
else:
subcls = get_unique_interplevel_subclass(
self.config, cls, w_subtype.hasdict, w_subtype.nslots != 0,
w_subtype.needsdel, w_subtype.weakrefable)
instance = instantiate(subcls)
assert isinstance(instance, cls)
instance.user_setup(self, w_subtype)
else:
raise operationerrfmt(self.w_TypeError,
"%s.__new__(%s): only for the type %s",
w_type.name, w_subtype.getname(self),
w_type.name)
return instance
def allocate_instance(self, cls, w_subtype):
"""Allocate the memory needed for an instance of an internal or
user-defined type, without actually __init__ializing the instance."""
w_type = self.gettypeobject(cls.typedef)
if self.is_w(w_type, w_subtype):
instance = instantiate(cls)
elif cls.typedef.acceptable_as_base_class:
# the purpose of the above check is to avoid the code below
# to be annotated at all for 'cls' if it is not necessary
w_subtype = w_type.check_user_subclass(w_subtype)
if cls.typedef.applevel_subclasses_base is not None:
cls = cls.typedef.applevel_subclasses_base
#
subcls = get_unique_interplevel_subclass(self, cls)
instance = instantiate(subcls)
assert isinstance(instance, cls)
instance.user_setup(self, w_subtype)
if w_subtype.hasuserdel:
self.finalizer_queue.register_finalizer(instance)
else:
raise oefmt(self.w_TypeError,
"%N.__new__(%N): only for the type %N", w_type,
w_subtype, w_type)
return instance
def allocate_instance(self, cls, w_subtype):
"""Allocate the memory needed for an instance of an internal or
user-defined type, without actually __init__ializing the instance."""
w_type = self.gettypeobject(cls.typedef)
if self.is_w(w_type, w_subtype):
instance = instantiate(cls)
elif cls.typedef.acceptable_as_base_class:
# the purpose of the above check is to avoid the code below
# to be annotated at all for 'cls' if it is not necessary
w_subtype = w_type.check_user_subclass(w_subtype)
if cls.typedef.applevel_subclasses_base is not None:
cls = cls.typedef.applevel_subclasses_base
#
if not we_are_translated():
if issubclass(cls, model.W_Object):
# If cls is missing from model.typeorder, then you
# need to add it there (including the inheritance
# relationship, if any)
assert cls in self.model.typeorder, repr(cls)
#
if (self.config.objspace.std.withmapdict and cls is W_ObjectObject
and not w_subtype.needsdel):
from pypy.objspace.std.mapdict import get_subclass_of_correct_size
subcls = get_subclass_of_correct_size(self, cls, w_subtype)
else:
subcls = get_unique_interplevel_subclass(
self.config, cls, w_subtype.hasdict, w_subtype.nslots != 0,
w_subtype.needsdel, w_subtype.weakrefable)
instance = instantiate(subcls)
assert isinstance(instance, cls)
instance.user_setup(self, w_subtype)
else:
raise operationerrfmt(self.w_TypeError,
"%s.__new__(%s): only for the type %s",
w_type.name, w_subtype.getname(self), w_type.name)
return instance
