def getweakref(self):
return self._lifeline_
def setweakref(self, space, weakreflifeline):
self._lifeline_ = weakreflifeline
class W_SetObject(W_BaseSetObject):
from pypy.objspace.std.settype import set_typedef as typedef
class W_FrozensetObject(W_BaseSetObject):
from pypy.objspace.std.frozensettype import frozenset_typedef as typedef
def __init__(w_self, space, setdata):
W_BaseSetObject.__init__(w_self, space, setdata)
w_self.hash = -1
registerimplementation(W_BaseSetObject)
registerimplementation(W_SetObject)
registerimplementation(W_FrozensetObject)
class W_SetIterObject(W_Object):
from pypy.objspace.std.settype import setiter_typedef as typedef
def __init__(w_self, setdata):
w_self.content = content = setdata
w_self.len = len(content)
w_self.pos = 0
w_self.iterator = w_self.content.iterkeys()
def next_entry(w_self):
for w_key in w_self.iterator:
return w_key
w_self.wrappeditems = wrappeditems
def __repr__(w_self):
""" representation for debugging purposes """
return "%s(%s)" % (w_self.__class__.__name__, w_self.wrappeditems)
def unwrap(w_list, space):
items = [space.unwrap(w_item) for w_item in w_list.wrappeditems
] # XXX generic mixed types unwrap
return list(items)
def append(w_list, w_item):
w_list.wrappeditems.append(w_item)
registerimplementation(W_ListObject)
init_signature = Signature(['sequence'], None, None)
init_defaults = [None]
def init__List(space, w_list, __args__):
# this is on the silly side
w_iterable, = __args__.parse_obj(None, 'list', init_signature,
init_defaults)
#
# this is the old version of the loop at the end of this function:
#
# w_list.wrappeditems = space.unpackiterable(w_iterable)
#
# This is commented out to avoid assigning a new RPython list to
return self.%s(%s)""" % (name, args, fallback, args, implname, args)
d = {}
exec py.code.Source(code).compile() in d
implementation_method = d[name]
implementation_method.func_defaults = getattr(W_DictMultiObject, implname).func_defaults
return implementation_method
def _install_methods():
for name, numargs in implementation_methods:
implname = "impl_" + name
fallbackname = "impl_fallback_" + name
func = _make_method(name, implname, fallbackname, numargs)
setattr(W_DictMultiObject, name, func)
_install_methods()
registerimplementation(W_DictMultiObject)
# DictImplementation lattice
# XXX fix me
# Iterator Implementation base classes
class IteratorImplementation(object):
def __init__(self, space, implementation):
self.space = space
self.dictimplementation = implementation
self.len = implementation.length()
self.pos = 0
def next(self):
if self.dictimplementation is None:
"""
from pypy.objspace.std.complextype import complex_typedef as typedef
def __init__(w_self, realval=0.0, imgval=0.0):
w_self.realval = float(realval)
w_self.imagval = float(imgval)
def unwrap(w_self, space): # for tests only
return complex(w_self.realval, w_self.imagval)
def __repr__(w_self):
""" representation for debugging purposes """
return "<W_ComplexObject(%f,%f)>" % (w_self.realval, w_self.imagval)
registerimplementation(W_ComplexObject)
c_1 = (1.0, 0.0)
def _sum(c1, c2):
return (c1[0]+c2[0],c1[1]+c2[1])
def _diff(c1, c2):
return (c1[0]-c2[0],c1[1]-c2[1])
def _neg(c):
return (-c[0],-c[1])
def _prod(c1, c2):
r = c1[0]*c2[0] - c1[1]*c2[1]
i = c1[0]*c2[1] + c1[1]*c2[0]
"""
from pypy.objspace.std.complextype import complex_typedef as typedef
_immutable_ = True
def __init__(w_self, realval=0.0, imgval=0.0):
w_self.realval = float(realval)
w_self.imagval = float(imgval)
def unwrap(w_self, space): # for tests only
return complex(w_self.realval, w_self.imagval)
def __repr__(w_self):
""" representation for debugging purposes """
return "<W_ComplexObject(%f,%f)>" % (w_self.realval, w_self.imagval)
registerimplementation(W_ComplexObject)
c_1 = (1.0, 0.0)
def _sum(c1, c2):
return (c1[0]+c2[0],c1[1]+c2[1])
def _diff(c1, c2):
return (c1[0]-c2[0],c1[1]-c2[1])
def _prod(c1, c2):
r = c1[0]*c2[0] - c1[1]*c2[1]
i = c1[0]*c2[1] + c1[1]*c2[0]
return (r,i)
def _quot(c1,c2):
class W_StringObject(W_Object):
from pypy.objspace.std.stringtype import str_typedef as typedef
_immutable_ = True
def __init__(w_self, str):
w_self._value = str
def __repr__(w_self):
""" representation for debugging purposes """
return "%s(%r)" % (w_self.__class__.__name__, w_self._value)
def unwrap(w_self, space):
return w_self._value
registerimplementation(W_StringObject)
W_StringObject.EMPTY = W_StringObject('')
W_StringObject.PREBUILT = [W_StringObject(chr(i)) for i in range(256)]
del i
def _decode_ascii(space, s):
try:
return s.decode("ascii")
except UnicodeDecodeError:
for i in range(len(s)):
if ord(s[i]) > 127:
raise OperationError(
space.w_UnicodeDecodeError,
space.newtuple([
space.wrap('ascii'),
def __init__(w_self, wrappeditems):
w_self.wrappeditems = wrappeditems
def __repr__(w_self):
""" representation for debugging purposes """
return "%s(%s)" % (w_self.__class__.__name__, w_self.wrappeditems)
def unwrap(w_list, space):
items = [space.unwrap(w_item) for w_item in w_list.wrappeditems]# XXX generic mixed types unwrap
return list(items)
def append(w_list, w_item):
w_list.wrappeditems.append(w_item)
registerimplementation(W_ListObject)
init_signature = Signature(['sequence'], None, None)
init_defaults = [None]
def init__List(space, w_list, __args__):
# this is on the silly side
w_iterable, = __args__.parse_obj(
None, 'list', init_signature, init_defaults)
#
# this is the old version of the loop at the end of this function:
#
# w_list.wrappeditems = space.unpackiterable(w_iterable)
#
# This is commented out to avoid assigning a new RPython list to
def __repr__(w_self):
""" representation for debugging purposes """
return "%s(%r)" % (w_self.__class__.__name__, w_self._value)
def unwrap(w_self, space):
# for testing
return w_self._value
def create_if_subclassed(w_self):
if type(w_self) is W_UnicodeObject:
return w_self
return W_UnicodeObject(w_self._value)
W_UnicodeObject.EMPTY = W_UnicodeObject(u'')
registerimplementation(W_UnicodeObject)
# Helper for converting int/long
def unicode_to_decimal_w(space, w_unistr):
if not isinstance(w_unistr, W_UnicodeObject):
raise operationerrfmt(space.w_TypeError,
"expected unicode, got '%s'",
space.type(w_unistr).getname(space, '?'))
unistr = w_unistr._value
result = ['\0'] * len(unistr)
digits = [ '0', '1', '2', '3', '4',
'5', '6', '7', '8', '9']
for i in xrange(len(unistr)):
uchr = ord(unistr[i])
if unicodedb.isspace(uchr):
result[i] = ' '
from pypy.objspace.std.stringtype import str_typedef as typedef
_immutable_ = True
def __init__(w_self, str):
w_self._value = str
def __repr__(w_self):
""" representation for debugging purposes """
return "%s(%r)" % (w_self.__class__.__name__, w_self._value)
def unwrap(w_self, space):
return w_self._value
registerimplementation(W_StringObject)
W_StringObject.EMPTY = W_StringObject("")
W_StringObject.PREBUILT = [W_StringObject(chr(i)) for i in range(256)]
del i
def _decode_ascii(space, s):
try:
return s.decode("ascii")
except UnicodeDecodeError:
for i in range(len(s)):
if ord(s[i]) > 127:
raise OperationError(
space.w_UnicodeDecodeError,
space.newtuple(
W_RopeObject.EMPTY = W_RopeObject(rope.LiteralStringNode.EMPTY)
W_RopeObject.PREBUILT = [
W_RopeObject(rope.LiteralStringNode.PREBUILT[i]) for i in range(256)
]
del i
def rope_w(space, w_str):
if isinstance(w_str, W_RopeObject):
return w_str._node
return rope.LiteralStringNode(space.str_w(w_str))
registerimplementation(W_RopeObject)
class W_RopeIterObject(W_Object):
from pypy.objspace.std.itertype import iter_typedef as typedef
def __init__(w_self, w_rope, index=0):
w_self.node = node = w_rope._node
w_self.item_iter = rope.ItemIterator(node)
w_self.index = index
registerimplementation(W_RopeIterObject)
def _is_generic(space, w_self, fun):
if type(w_self) is W_RopeObject:
return w_self
return W_RopeObject(w_self._node)
W_RopeObject.EMPTY = W_RopeObject(rope.LiteralStringNode.EMPTY)
W_RopeObject.PREBUILT = [W_RopeObject(rope.LiteralStringNode.PREBUILT[i])
for i in range(256)]
del i
def rope_w(space, w_str):
if isinstance(w_str, W_RopeObject):
return w_str._node
return rope.LiteralStringNode(space.str_w(w_str))
registerimplementation(W_RopeObject)
class W_RopeIterObject(W_Object):
from pypy.objspace.std.itertype import iter_typedef as typedef
def __init__(w_self, w_rope, index=0):
w_self.node = node = w_rope._node
w_self.item_iter = rope.ItemIterator(node)
w_self.index = index
registerimplementation(W_RopeIterObject)
def _is_generic(space, w_self, fun):
l = w_self._node.length()
if l == 0:
return space.w_False
