def make_bootstrap_objects(self):
self.make_bootstrap_object("w_charactertable")
self.make_bootstrap_object("w_true")
self.make_bootstrap_object("w_false")
self.make_bootstrap_object("w_special_selectors")
self.add_bootstrap_object("w_minus_one", model.W_SmallInteger(-1))
self.add_bootstrap_object("w_zero", model.W_SmallInteger(0))
self.add_bootstrap_object("w_one", model.W_SmallInteger(1))
self.add_bootstrap_object("w_two", model.W_SmallInteger(2))
# Certain special objects are already created. The rest will be
# populated when the image is loaded, but prepare empty slots for them.
for name in constants.objects_in_special_object_table:
name = "w_" + name
if not name in self.objtable:
self.add_bootstrap_object(name, None)
def make_bootstrap_objects(self):
def bld_char(i):
w_cinst = self.w_Character.as_class_get_shadow(self).new()
w_cinst.store(self, constants.CHARACTER_VALUE_INDEX,
model.W_SmallInteger(i))
return w_cinst
w_charactertable = model.W_PointersObject(self,
self.classtable['w_Array'],
256)
self.w_charactertable = w_charactertable
for i in range(256):
self.w_charactertable.atput0(self, i, bld_char(i))
# Very special nil hack: in order to allow W_PointersObject's to
# initialize their fields to nil, we have to create it in the model
# package, and then patch up its fields here:
def patch_nil(w_nil):
from spyvm.fieldtypes import nilTyper
w_nil.space = self
w_nil.fieldtypes = nilTyper
w_nil.s_class = self.classtable[
'w_UndefinedObject'].as_class_get_penumbra(self)
return w_nil
w_nil = self.w_nil = patch_nil(model.w_nil)
w_true = self.classtable['w_True'].as_class_get_shadow(self).new()
self.w_true = w_true
w_false = self.classtable['w_False'].as_class_get_shadow(self).new()
self.w_false = w_false
self.w_minus_one = model.W_SmallInteger(-1)
self.w_zero = model.W_SmallInteger(0)
self.w_one = model.W_SmallInteger(1)
self.w_two = model.W_SmallInteger(2)
w_special_selectors = model.W_PointersObject(
self, self.classtable['w_Array'],
len(constants.SPECIAL_SELECTORS) * 2)
self.w_special_selectors = w_special_selectors
self.objtable = {}
for name in constants.objects_in_special_object_table:
name = "w_" + name
try:
self.objtable[name] = locals()[name]
except KeyError, e:
self.objtable[name] = None
def wrap_positive_32bit_int(self, val):
# This will always return a positive value.
# XXX: For now, we assume that val is at most 32bit, i.e. overflows are
# checked for before wrapping. Also, we ignore tagging.
if int_between(0, val, constants.MAXINT):
return model.W_SmallInteger(val)
else:
return model.W_LargePositiveInteger1Word(val)
def test_weak_pointers():
w_cls = bootstrap_class(2)
s_cls = w_cls.as_class_get_shadow(space)
s_cls.instance_kind = storage_classes.WEAK_POINTERS
weak_object = s_cls.new()
referenced = model.W_SmallInteger(10)
referenced2 = model.W_SmallInteger(20)
weak_object.store(space, 0, referenced)
weak_object.store(space, 1, referenced2)
assert weak_object.fetch(space, 0) is referenced
del referenced
# When executed using pypy, del is not immediately executed.
# Thus the reference may linger until the next gc...
import gc
gc.collect()
assert weak_object.fetch(space, 0).is_nil(space)
assert weak_object.fetch(space, 1).value == 20
def test_hashes():
w_five = model.W_SmallInteger(5)
assert w_five.gethash() == 5
w_class = mockclass(space, 0)
w_inst = w_class.as_class_get_shadow(space).new()
assert w_inst.hash == w_inst.UNASSIGNED_HASH
h1 = w_inst.gethash()
h2 = w_inst.gethash()
assert h1 == h2
assert h1 == w_inst.hash
def test_not_is_same_object(w_o1=model.W_PointersObject(space, None, 0),
w_o2=model.W_PointersObject(space, None, 0)):
assert not w_o1.is_same_object(w_o2)
assert not w_o2.is_same_object(w_o1)
w_o2 = model.W_SmallInteger(2)
assert not w_o1.is_same_object(w_o2)
assert not w_o2.is_same_object(w_o1)
w_o2 = model.W_Float(5.5)
assert not w_o1.is_same_object(w_o2)
assert not w_o2.is_same_object(w_o1)
def test_word_atput():
i = model.W_SmallInteger(100)
b = model.W_WordsObject(space, None, 1)
b.atput0(space, 0, i)
assert 100 == b.getword(0)
i = space.classtable['w_LargePositiveInteger'].as_class_get_shadow(
space).new(4)
i.atput0(space, 3, space.wrap_int(192))
b.atput0(space, 0, i)
assert b.getword(0) == 3221225472
def setup():
from spyvm import objspace
space = objspace.ObjSpace()
image = create_testimage(space)
interp = interpreter.Interpreter(space, image)
w_selector = interp.perform(space.wrap_string("loopTest"), "asSymbol")
w_object = model.W_SmallInteger(0)
s_class = w_object.shadow_of_my_class(space)
s_method = s_class.lookup(w_selector)
s_frame = s_method.create_frame(space, w_object, [])
return interp, s_frame
def setup():
space = objspace.ObjSpace()
stream = squeakimage.Stream(filename=imagefile)
image = squeakimage.ImageReader(space, stream).create_image()
interp = interpreter.Interpreter(space, image)
w_selector = interp.perform(space.wrap_string("loopTest"), "asSymbol")
w_object = model.W_SmallInteger(0)
s_class = w_object.class_shadow(space)
w_method = s_class.lookup(w_selector)
s_frame = w_method.create_frame(space, w_object)
return interp, s_frame
def wrap_int(self, val):
if isinstance(val, r_longlong) and not is_valid_int(val):
if val > 0 and r_ulonglong(val) < r_uint(constants.U_MAXINT):
return self.wrap_positive_32bit_int(intmask(val))
else:
raise WrappingError
elif isinstance(val, r_uint):
return self.wrap_positive_32bit_int(intmask(val))
elif not is_valid_int(val):
raise WrappingError
# we don't do tagging
return model.W_SmallInteger(intmask(val))
def test_not_is_same_object(w_o1=None, w_o2=None):
if w_o1 is None:
w_o1 = model.W_PointersObject(space, None, 0)
if w_o2 is None:
w_o2 = model.W_PointersObject(space, None, 0)
assert not w_o1.is_same_object(w_o2)
assert not w_o2.is_same_object(w_o1)
w_o2 = model.W_SmallInteger(2)
assert not w_o1.is_same_object(w_o2)
assert not w_o2.is_same_object(w_o1)
w_o2 = model.W_Float(5.5)
assert not w_o1.is_same_object(w_o2)
assert not w_o2.is_same_object(w_o1)
def patch_bootstrap_objects(self):
def patch_bootstrap_object(obj, cls, size):
obj.w_class = cls
obj.initialize_storage(self, size)
patch_bootstrap_object(self.w_nil, self.w_UndefinedObject, 0)
patch_bootstrap_object(self.w_true, self.w_True, 0)
patch_bootstrap_object(self.w_false, self.w_False, 0)
patch_bootstrap_object(self.w_special_selectors, self.w_Array,
len(constants.SPECIAL_SELECTORS) * 2)
patch_bootstrap_object(self.w_charactertable, self.w_Array, 256)
# Bootstrap character table
for i in range(256):
w_cinst = model.W_PointersObject(self, self.w_Character, 1)
w_cinst.store(self, constants.CHARACTER_VALUE_INDEX,
model.W_SmallInteger(i))
self.w_charactertable.store(self, i, w_cinst)
def test_weak_pointers():
from spyvm.shadow import WEAK_POINTERS
w_cls = mockclass(space, 1)
s_cls = w_cls.as_class_get_shadow(space)
s_cls.instance_kind = WEAK_POINTERS
weak_object = s_cls.new()
referenced = model.W_SmallInteger(10)
weak_object.store(space, 0, referenced)
assert weak_object.fetch(space, 0) is referenced
del referenced
# When executed using pypy, del is not immediately executed.
# Thus the reference may linger until the next gc...
import gc
gc.collect()
assert weak_object.fetch(space, 0) is space.w_nil
def tinyBenchmarks():
image = create_squeakimage()
interp = interpreter.Interpreter()
w_object = model.W_SmallInteger(0)
# Should get this from w_object
w_smallint_class = image.special(constants.SO_SMALLINTEGER_CLASS)
s_class = w_object.shadow_of_my_class()
#w_method = s_class.lookup("benchFib")
w_method = s_class.lookup("tinyBenchmarks")
assert w_method
w_frame = w_method.create_frame(w_object, [])
interp.store_w_active_context(w_frame)
from spyvm.interpreter import BYTECODE_TABLE
while True:
try:
interp.step()
except interpreter.ReturnFromTopLevel, e:
print e.object
return
def wrap_int(self, val):
from spyvm import constants
assert isinstance(val, int)
# we don't do tagging
return model.W_SmallInteger(val)
def test_lookup_abs_in_integer():
w_abs = interp.perform(w("abs"), "asSymbol")
for value in [10, -3, 0]:
w_object = model.W_SmallInteger(value)
w_res = interp.perform(w_object, w_abs)
assert w_res.value == abs(value)
def test_intfloat_notis_same_object():
test_not_is_same_object(model.W_SmallInteger(1), model.W_Float(1))
test_not_is_same_object(model.W_Float(100), model.W_SmallInteger(100))
test_not_is_same_object(model.W_Float(1.100), model.W_Float(1.200))
test_not_is_same_object(model.W_SmallInteger(101),
model.W_SmallInteger(100))
def interp_w():
interp.perform(model.W_SmallInteger(1000), w_selector)
def bld_char(i):
w_cinst = self.w_Character.as_class_get_shadow(self).new()
w_cinst.store(self, constants.CHARACTER_VALUE_INDEX,
model.W_SmallInteger(i))
return w_cinst
