def test_not_is_same_object(w_o1=model.W_PointersObject(None,0),w_o2=model.W_PointersObject(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_accessor_generators():
w_o = model.W_PointersObject(None, 1)
w = wrapper.LinkWrapper(space, w_o)
w_o._vars[0] = "hello"
assert w.next_link() == "hello"
w.store_next_link("boe")
assert w.next_link() == "boe"
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.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:
w_nil = self.w_nil = model.w_nil
w_nil.w_class = self.classtable['w_UndefinedObject']
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)
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 new_scheduler(w_process=space.w_nil, prioritydict=None):
priority_list = new_prioritylist(prioritydict)
w_scheduler = model.W_PointersObject(None, 2)
scheduler = wrapper.SchedulerWrapper(space, w_scheduler)
scheduler.store_active_process(w_process)
scheduler.write(0, priority_list.w_self)
return scheduler
def test_linked_list():
w_object = model.W_PointersObject(None, 2)
w_last = link(space.w_nil)
w_lb1 = link(w_last)
w_lb2 = link(w_lb1)
w_lb3 = link(w_lb2)
w_lb4 = link(w_lb3)
w_first = link(w_lb4)
linkedlist = wrapper.LinkedListWrapper(space, w_object)
linkedlist.store_first_link(w_first)
linkedlist.store_last_link(w_last)
assert w_first is linkedlist.first_link()
assert w_last is linkedlist.last_link()
assert linkedlist.remove_first_link_of_list() is w_first
assert linkedlist.remove_first_link_of_list() is w_lb4
assert linkedlist.remove_first_link_of_list() is w_lb3
assert not linkedlist.is_empty_list()
assert linkedlist.remove_first_link_of_list() is w_lb2
assert linkedlist.remove_first_link_of_list() is w_lb1
assert linkedlist.remove_first_link_of_list() is w_last
assert linkedlist.is_empty_list()
linkedlist.add_last_link(w_first)
assert linkedlist.first_link() is w_first
assert linkedlist.last_link() is w_first
linkedlist.add_last_link(w_last)
assert linkedlist.first_link() is w_first
assert linkedlist.last_link() is w_last
py.test.raises(WrapperException, linkedlist.remove, space.w_nil)
linkedlist.remove(w_first)
assert linkedlist.first_link() is w_last
linkedlist.store_first_link(w_first)
wrapper.LinkWrapper(space, w_first).store_next_link(w_last)
linkedlist.remove(w_last)
assert linkedlist.last_link() is w_first
def test_simpleread():
w_o = model.W_PointersObject(None, 2)
w = wrapper.Wrapper(space, w_o)
w_o._vars[0] = "hello"
assert w.read(0) == "hello"
w.write(1, "b")
assert w.read(1) == "b"
py.test.raises(WrapperException, "w.read(2)")
py.test.raises(WrapperException, "w.write(2, \"test\")")
def new_prioritylist(prioritydict=None):
if prioritydict is not None:
maxpriority = max(prioritydict.keys())
else:
maxpriority = 5
prioritydict = {}
w_prioritylist = model.W_PointersObject(None, maxpriority)
prioritylist = wrapper.Wrapper(space, w_prioritylist)
for i in range(maxpriority):
prioritylist.write(i, new_processlist(prioritydict.get(i, [])).w_self)
return prioritylist
def new_processlist(processes_w=[]):
w_processlist = model.W_PointersObject(None, 2)
w_first = space.w_nil
w_last = space.w_nil
for w_process in processes_w[::-1]:
w_first = newprocess(w_first, w_processlist).w_self
if w_last is space.w_nil:
w_last = w_first
pl = wrapper.ProcessListWrapper(space, w_processlist)
pl.store_first_link(w_first)
pl.store_last_link(w_last)
return pl
def new_process(w_next=space.w_nil,
w_my_list=space.w_nil,
w_suspended_context=space.w_nil,
priority=0):
w_priority = space.wrap_int(priority)
w_process = model.W_PointersObject(None, 4)
process = wrapper.ProcessWrapper(space, w_process)
process.store_next_link(w_next)
process.store_my_list(w_my_list)
process.store_suspended_context(w_suspended_context)
process.write(2, w_priority)
return process
def make_context(space, w_home, w_sender, argcnt, initialip):
# create and attach a shadow manually, to not have to carefully put things
# into the right places in the W_PointersObject
# XXX could hack some more to never have to create the _vars of w_result
contextsize = w_home.as_methodcontext_get_shadow(space).myblocksize()
w_result = model.W_PointersObject(space.w_BlockContext, contextsize)
s_result = BlockContextShadow(space, w_result)
w_result.store_shadow(s_result)
s_result.store_expected_argument_count(argcnt)
s_result.store_initialip(initialip)
s_result.store_w_home(w_home)
s_result.store_pc(initialip)
return w_result
def new(self, extrasize=0):
w_cls = self.w_self()
if self.instance_kind == POINTERS:
w_new = model.W_PointersObject(w_cls,
self.instance_size + extrasize)
elif self.instance_kind == WORDS:
w_new = model.W_WordsObject(w_cls, extrasize)
elif self.instance_kind == BYTES:
w_new = model.W_BytesObject(w_cls, extrasize)
elif self.instance_kind == COMPILED_METHOD:
w_new = model.W_CompiledMethod(extrasize)
else:
raise NotImplementedError(self.instance_kind)
return w_new
def blockcontext(w_sender=space.w_nil,
pc=1,
stackpointer=1,
stacksize=5,
home=methodcontext()):
w_object = model.W_PointersObject(
space.w_MethodContext, constants.MTHDCTX_TEMP_FRAME_START + stacksize)
w_object.store(space, constants.CTXPART_SENDER_INDEX, w_sender)
w_object.store(space, constants.CTXPART_PC_INDEX, space.wrap_int(pc))
w_object.store(space, constants.CTXPART_STACKP_INDEX,
space.wrap_int(stackpointer))
w_object.store(space, constants.BLKCTX_BLOCK_ARGUMENT_COUNT_INDEX,
space.wrap_int(54))
w_object.store(space, constants.BLKCTX_INITIAL_IP_INDEX,
space.wrap_int(17))
w_object.store(space, constants.BLKCTX_HOME_INDEX, home)
w_object.store(space, constants.BLKCTX_STACK_START, 'el')
return w_object
def build_smalltalk_class(name,
format,
w_superclass=w_Object,
w_classofclass=None,
methods={}):
if w_classofclass is None:
w_classofclass = build_smalltalk_class(None, 0x94,
w_superclass.w_class,
w_Metaclass)
w_methoddict = build_methoddict(methods)
size = constants.CLASS_NAME_INDEX + 1
w_class = model.W_PointersObject(w_classofclass, size)
w_class.store(constants.CLASS_SUPERCLASS_INDEX, w_superclass)
w_class.store(constants.CLASS_METHODDICT_INDEX, w_methoddict)
w_class.store(constants.CLASS_FORMAT_INDEX, utility.wrap_int(format))
if name is not None:
w_class.store(constants.CLASS_NAME_INDEX, utility.wrap_string(name))
return w_class
def methodcontext(w_sender=space.w_nil,
pc=1,
stackpointer=0,
stacksize=5,
method=method()):
w_object = model.W_PointersObject(
space.w_MethodContext,
constants.MTHDCTX_TEMP_FRAME_START + method.tempsize + stacksize)
w_object.store(space, constants.CTXPART_SENDER_INDEX, w_sender)
w_object.store(space, constants.CTXPART_PC_INDEX, space.wrap_int(pc))
w_object.store(space, constants.CTXPART_STACKP_INDEX,
space.wrap_int(method.tempsize + stackpointer))
w_object.store(space, constants.MTHDCTX_METHOD, method)
# XXX
w_object.store(space, constants.MTHDCTX_RECEIVER_MAP, '???')
w_object.store(space, constants.MTHDCTX_RECEIVER, 'receiver')
w_object.store(space, constants.MTHDCTX_TEMP_FRAME_START, 'el')
return w_object
def bootstrap_class(instsize,
w_superclass=None,
w_metaclass=None,
name='?',
format=shadow.POINTERS,
varsized=False):
from pypy.lang.smalltalk import model
w_class = model.W_PointersObject(w_metaclass, 0)
# a dummy placeholder for testing
s = shadow.ClassShadow(w_class)
s.methoddict = {}
if w_superclass is not None:
s.s_superclass = w_superclass.as_class_get_shadow()
s.name = name
s.instance_size = instsize
s.instance_kind = format
s.instance_varsized = varsized or format != shadow.POINTERS
s.invalid = False
w_class._shadow = s
return w_class
def new(self, extrasize=0):
from pypy.lang.smalltalk import classtable
w_cls = self.w_self
if w_cls == classtable.w_BlockContext:
return model.W_BlockContext(None, None, 0, 0)
elif w_cls == classtable.w_MethodContext:
# From slang: Contexts must only be created with newForMethod:
raise error.PrimitiveFailedError
if self.instance_kind == POINTERS:
return model.W_PointersObject(w_cls,
self.instance_size + extrasize)
elif self.instance_kind == WORDS:
return model.W_WordsObject(w_cls, extrasize)
elif self.instance_kind == BYTES:
return model.W_BytesObject(w_cls, extrasize)
elif self.instance_kind == COMPILED_METHOD:
return model.W_CompiledMethod(extrasize)
else:
raise NotImplementedError(self.instance_kind)
def bootstrap_class(space,
instsize,
w_superclass=None,
w_metaclass=None,
name='?',
format=shadow.POINTERS,
varsized=False):
from pypy.lang.smalltalk import model
w_class = model.W_PointersObject(w_metaclass, 0)
# a dummy placeholder for testing
# XXX
s = instantiate(shadow.ClassShadow)
s.space = space
s._w_self = w_class
s.w_superclass = w_superclass
s.name = name
s.instance_size = instsize
s.instance_kind = format
s.w_methoddict = None
s.instance_varsized = varsized or format != shadow.POINTERS
s.invalid = False
w_class.store_shadow(s)
return w_class
def new_semaphore(excess_signals=0):
w_semaphore = model.W_PointersObject(None, 3)
semaphore = wrapper.SemaphoreWrapper(space, w_semaphore)
semaphore.store_excess_signals(space, excess_signals)
return semaphore
def initialize_methoddict(self):
"NOT_RPYTHON" # this is only for testing.
if self.w_methoddict is None:
self.w_methoddict = model.W_PointersObject(None, 2)
self.w_methoddict._store(1, model.W_PointersObject(None, 0))
self.s_methoddict().invalid = False
def test_is_same_object(w_o1=model.W_PointersObject(None,0), w_o2=None):
if w_o2 is None:
w_o2 = w_o1
assert w_o1.is_same_object(w_o2)
assert w_o2.is_same_object(w_o1)
def link(w_next='foo'):
w_object = model.W_PointersObject(None, 1)
wrapper.LinkWrapper(space, w_object).store_next_link(w_next)
return w_object