def test_accessor_generators():
w_o = W_PointersObject(space, None, 1)
w = wrapper.LinkWrapper(space, w_o)
w_o.store(space, 0, "hello")
assert w.next_link() == "hello"
w.store_next_link("boe")
assert w.next_link() == "boe"
def test_accessor_generators():
w_o = W_PointersObject(space, None, 1)
w = wrapper.LinkWrapper(space, w_o)
w_o.store(space, 0, "hello")
assert w.next_link() == "hello"
w.store_next_link("boe")
assert w.next_link() == "boe"
def test_ContextPart_jump():
"""
Code: Create a Block context that jumps back to its sender, instead of returning normally.
The Block is not executed to the end, the sender chain is manipulated.
The local variable should be the value pushed on the sender context before jumping to it.
a := 5.
a := [ thisContext sender push: 2. thisContext sender jump. 10 ] value.
^ a
"""
ContextPart = space.w_MethodContext.as_class_get_shadow(space).s_superclass().w_self()
push = find_symbol("push:", ContextPart)
sender = find_symbol("sender", ContextPart)
jump = find_symbol("jump", ContextPart)
bytes = [0x21, 0x82, 0xc0, # Set a
0x8f, 0x00, 0x00, 0x0b, # Push block
0x89, 0xd3, # Send sender
0x77, 0xe2, # Send push
0x87, 0x89, 0xd3, 0xd4, # Send jump
0x87, 0x25, 0x7d, # Block rest (not executed)
0xc9, 0x82, 0xc0, 0x40, 0x7c] # Send value and return
Association = space.w_Point # Wrong class, doesn't matter.
assoc = W_PointersObject(space, Association, 2)
assoc.store(space, 0, w('a'))
assoc.store(space, 1, w(3))
w_method = space.make_method(bytes, [assoc, w(5), push, sender, jump, w(10)])
result = interp.execute_method(w_method)
assert isinstance(result, W_SmallInteger)
assert result.value == 2
def initialize_methoddict(self):
if self._s_methoddict is None:
w_methoddict = W_PointersObject(self.space, None, 2)
w_methoddict.store(self.space, constants.METHODDICT_VALUES_INDEX,
W_PointersObject(self.space, None, 0))
self.store_s_methoddict(
w_methoddict.as_methoddict_get_shadow(self.space))
def test_simpleread():
w_o = W_PointersObject(space, None, 2)
w = wrapper.Wrapper(space, w_o)
w_o.store(space, 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 test_simpleread():
w_o = W_PointersObject(space, None, 2)
w = wrapper.Wrapper(space, w_o)
w_o.store(space, 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 test_primImmutableFrom_pointers():
size = 10
w_pointers_cls = bootstrap_class(0)
w_pointers_obj = W_PointersObject(space, w_pointers_cls, size)
w_pointers_obj.store(space, 0, space.w_true)
w_ipointers_obj = external_call(space, 'ImmutabilityPlugin',
'primitiveImmutableFrom',
[w_pointers_cls, w_pointers_obj])
assert w_ipointers_obj.is_immutable()
assert w_ipointers_obj.getclass(space).is_same_object(w_pointers_cls)
assert w_ipointers_obj.size() == size
assert w_ipointers_obj.fetch(space, 0) is space.w_true
w_ipointers_obj.store(space, 0, space.w_false)
assert w_ipointers_obj.fetch(space, 0) is space.w_true
def test_primImmutableFrom_pointers():
size = 10
w_pointers_cls = bootstrap_class(0)
w_pointers_obj = W_PointersObject(space, w_pointers_cls, size)
w_pointers_obj.store(space, 0, space.w_true)
w_ipointers_obj = external_call(space,
'ImmutabilityPlugin',
'primitiveImmutableFrom',
[w_pointers_cls, w_pointers_obj])
assert w_ipointers_obj.is_immutable()
assert w_ipointers_obj.getclass(space).is_same_object(w_pointers_cls)
assert w_ipointers_obj.size() == size
assert w_ipointers_obj.fetch(space, 0) is space.w_true;
w_ipointers_obj.store(space, 0, space.w_false)
assert w_ipointers_obj.fetch(space, 0) is space.w_true;
def create_process(interp, s_frame):
space = interp.space
w_active_process = wrapper.scheduler(space).active_process()
assert isinstance(w_active_process, W_PointersObject)
w_benchmark_proc = W_PointersObject(
space, w_active_process.getclass(space), w_active_process.size()
)
if interp.image.version.has_closures:
# Priorities below 10 are not allowed in newer versions of Squeak.
active_priority = space.unwrap_int(w_active_process.fetch(space, 2))
priority = active_priority / 2 + 1
priority = max(11, priority)
else:
priority = 7
w_benchmark_proc.store(space, 1, s_frame.w_self())
w_benchmark_proc.store(space, 2, space.wrap_int(priority))
# Make process eligible for scheduling
wrapper.ProcessWrapper(space, w_benchmark_proc).put_to_sleep()
def create_process(interp, s_frame):
space = interp.space
w_active_process = wrapper.scheduler(space).active_process()
assert isinstance(w_active_process, W_PointersObject)
w_benchmark_proc = W_PointersObject(space,
w_active_process.getclass(space),
w_active_process.size())
if interp.image.version.has_closures:
# Priorities below 10 are not allowed in newer versions of Squeak.
active_priority = space.unwrap_int(w_active_process.fetch(space, 2))
priority = active_priority / 2 + 1
priority = max(11, priority)
else:
priority = 7
w_benchmark_proc.store(space, 1, s_frame.w_self())
w_benchmark_proc.store(space, 2, space.wrap_int(priority))
# Make process eligible for scheduling
wrapper.ProcessWrapper(space, w_benchmark_proc).put_to_sleep()
def test_semaphore():
w_semaphore_cls = space.w_timerSemaphore().getclass(space)
w_sema = image.find_symbol(space, reader, "Semaphore")
w_fork = image.find_symbol(space, reader, "fork")
w_wait = image.find_symbol(space, reader, "wait")
w_yield = image.find_symbol(space, reader, "yield")
w_processor = space.w_schedulerassociationpointer
w_suspPrimOFail = image.find_symbol(space, reader, "suspendPrimitivelyOrFail")
bytes = [
0x40, # pushLit: Semaphore
0xCC, # send: new
0x6A, # popIntoTemp: 2
0x12, # pushTemp: 2
0x8F, 0x10, 0x00, 0x03, # closureNumCopied: 1 numArgs: 0 bytes 49 to 51
0x10, # pushTemp: 0
0xD2, # send: wait
0x7D, # blockReturn
0xD1, # send: fork
0x69, # popIntoTemp: 1
0x44, # pushLit: Processor
0xD3, # send: yield
0x87, # pop
0x11, # pushTemp: 1
0xD5, # send: suspendPrimitivelyOrFail
0x68, # popIntoTemp: 0
0x10, # pushTemp: 0
0x7C, # returnTop
]
Association = space.w_Point # Wrong class, doesn't matter.
semaAssoc = W_PointersObject(space, Association, 2)
semaAssoc.store(space, 0, w_sema)
semaAssoc.store(space, 1, w_semaphore_cls)
w_method = space.make_method(bytes, [semaAssoc, w_fork, w_wait, w_yield, w_processor, w_suspPrimOFail, w('nothing')])
result = interp.execute_method(w_method)
import pdb; pdb.set_trace()
assert isinstance(result, W_PointersObject)
def test_ContextPart_jump_nonlocal():
"""
Like above test, but with three blocks to make the return non-local.
Also, store the outer context beforehand.
a := 5.
outer := thisContext.
a := [[[ outer push: 2. outer jump. 10 ] value ] value] value.
^ a
"""
ContextPart = space.w_MethodContext.as_class_get_shadow(space).s_superclass().w_self()
push = find_symbol("push:", ContextPart)
jump = find_symbol("jump", ContextPart)
bytes = [0x21, 0x82, 0xc0, # Set a
0x89, 0x82, 0xc2, # Set outer
0x8f, 0x00, 0x00, 0x15, # Push block
0x8f, 0x00, 0x00, 0x0f, # Push block
0x8f, 0x00, 0x00, 0x09, # Push block
0x42, 0x77, 0xe3, # Push 2
0x87, 0x42, 0xd4, # Send jump
0x87, 0x25, 0x7d, # Block rest (not executed)
0xc9, 0x7d, # Send value and return
0xc9, 0x7d, # Send value and return
0xc9, 0x82, 0xc0, 0x40, 0x7c] # Send value and return
Association = space.w_Point # Wrong class, doesn't matter.
assoc = W_PointersObject(space, Association, 2)
assoc.store(space, 0, w('a'))
assoc.store(space, 1, space.w_nil)
assoc2 = W_PointersObject(space, Association, 2)
assoc2.store(space, 0, w('outer'))
assoc2.store(space, 1, space.w_nil)
w_method = space.make_method(bytes, [assoc, w(5), assoc2, push, jump, w(10)])
result = interp.execute_method(w_method)
assert isinstance(result, W_SmallInteger)
assert result.value == 2
def store(self, space, n0, w_value):
self.ivar_cache[n0] = w_value
cls = w_value.getclass(space)
if (cls.is_same_object(space.w_String)):
aType = TEXT
elif cls.is_same_object(space.w_SmallInteger):
aType = INTEGER
elif cls.is_same_object(space.w_Float):
aType = REAL
elif cls.is_same_object(space.w_nil):
aType = NIL
else:
if isinstance(w_value, W_DBObject):
aType = BLOB
W_DBObject.state.db_objects[w_value.id] = w_value
# Save id in database.
w_value = w_value.w_id
else:
# print 'Unable to unwrap %s' % w_value.getclass(space)
# print 'Falling back to standard store.'
return W_PointersObject.store(self, space, n0, w_value)
aType = jit.promote(aType)
class_name = self.class_name(space)
if (aType is not NIL and
W_DBObject.state.get_column_type(class_name, n0) is NIL):
connection = dbm.connection()
connection.execute(space, alter_sql(class_name, n0, aType))
# print "invalidate cache"
connection.statement_cache.invalidate()
W_DBObject.state.set_column_type(class_name, n0, aType)
connection = dbm.connection()
connection.execute(space, update_sql(class_name, n0),
[w_value, self.w_id])
def store(self, space, n0, w_value):
self.ivar_cache[n0] = w_value
cls = w_value.getclass(space)
if (cls.is_same_object(space.w_String)):
aType = TEXT
elif cls.is_same_object(space.w_SmallInteger):
aType = INTEGER
elif cls.is_same_object(space.w_Float):
aType = REAL
elif cls.is_same_object(space.w_nil):
aType = NIL
else:
if isinstance(w_value, W_DBObject):
aType = BLOB
W_DBObject.state.db_objects[w_value.id] = w_value
# Save id in database.
w_value = w_value.w_id
else:
# print 'Unable to unwrap %s' % w_value.getclass(space)
# print 'Falling back to standard store.'
return W_PointersObject.store(self, space, n0, w_value)
aType = jit.promote(aType)
class_name = self.class_name(space)
if (aType is not NIL
and W_DBObject.state.get_column_type(class_name, n0) is NIL):
connection = dbm.connection()
connection.execute(space, alter_sql(class_name, n0, aType))
# print "invalidate cache"
connection.statement_cache.invalidate()
W_DBObject.state.set_column_type(class_name, n0, aType)
connection = dbm.connection()
connection.execute(space, update_sql(class_name, n0),
[w_value, self.w_id])
def build_smalltalk_class(name, format, w_superclass=None,
w_classofclass=None, methods={}, space=None):
if space is None:
space = globals()["space"]
if w_superclass is None:
w_superclass = w_Object
if w_classofclass is None:
w_classofclass = build_smalltalk_class(None, 0x94,
w_superclass.getclass(space),
w_Metaclass)
w_methoddict = build_methoddict(methods)
size = constants.CLASS_NAME_INDEX + 1
w_class = W_PointersObject(space, w_classofclass, size)
w_class.store(space, constants.CLASS_SUPERCLASS_INDEX, w_superclass)
w_class.store(space, constants.CLASS_METHODDICT_INDEX, w_methoddict)
w_class.store(space, constants.CLASS_FORMAT_INDEX, space.wrap_int(format))
if name is not None:
w_class.store(space, constants.CLASS_NAME_INDEX, space.wrap_string(name))
w_class.as_class_get_shadow(space).s_methoddict().sync_method_cache()
return w_class
def blockcontext(w_sender=None, pc=13, stackpointer=1, stacksize=5,
home=None):
if w_sender is None:
w_sender = space.w_nil
if home is None:
home = methodcontext()
w_object = W_PointersObject(space, space.w_BlockContext, 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, space.wrap_string('el'))
return w_object
def methodcontext(w_sender=None, pc=13, stackpointer=0, stacksize=5,
method=None):
if w_sender is None:
w_sender = space.w_nil
if method is None:
method = create_method()
w_object = W_PointersObject(space, 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_CLOSURE_OR_NIL, space.w_nil)
w_object.store(space, constants.MTHDCTX_RECEIVER, space.wrap_string('receiver'))
w_object.store(space, constants.MTHDCTX_TEMP_FRAME_START, space.wrap_string('el'))
return w_object
def test_primitive_be_display():
assert space.w_display() is space.w_nil
mock_display = W_PointersObject(space, space.w_Point, 4)
w_wordbmp = W_WordsObject(space, space.w_Bitmap, 10)
mock_display.store(space, 0, w_wordbmp) # bitmap
mock_display.store(space, 1, space.wrap_int(32)) # width
mock_display.store(space, 2, space.wrap_int(10)) # height
mock_display.store(space, 3, space.wrap_int(1)) # depth
prim(BE_DISPLAY, [mock_display])
assert space.w_display() is mock_display
w_bitmap = mock_display.fetch(space, 0)
assert w_bitmap is not w_wordbmp
assert isinstance(w_bitmap, W_DisplayBitmap)
sdldisplay = w_bitmap.display()
assert isinstance(sdldisplay, display.SDLDisplay)
mock_display2 = W_PointersObject(space, space.w_Point, 4)
mock_display2.store(space, 0, W_WordsObject(space, space.w_Bitmap,
10)) # bitmap
mock_display2.store(space, 1, space.wrap_int(32)) # width
mock_display2.store(space, 2, space.wrap_int(10)) # height
mock_display2.store(space, 3, space.wrap_int(1)) # depth
prim(BE_DISPLAY, [mock_display2])
assert space.w_display() is mock_display2
w_bitmap2 = mock_display.fetch(space, 0)
assert isinstance(w_bitmap2, W_DisplayBitmap)
assert w_bitmap.display() is w_bitmap2.display()
assert sdldisplay.width == 32
assert sdldisplay.height == 10
prim(BE_DISPLAY, [mock_display])
assert space.w_display() is mock_display
assert mock_display.fetch(space, 0) is w_bitmap
def test_primitive_be_display():
assert space.w_display() is space.w_nil
mock_display = W_PointersObject(space, space.w_Point, 4)
w_wordbmp = W_WordsObject(space, space.w_Bitmap, 10)
mock_display.store(space, 0, w_wordbmp) # bitmap
mock_display.store(space, 1, space.wrap_int(32)) # width
mock_display.store(space, 2, space.wrap_int(10)) # height
mock_display.store(space, 3, space.wrap_int(1)) # depth
prim(BE_DISPLAY, [mock_display])
assert space.w_display() is mock_display
w_bitmap = mock_display.fetch(space, 0)
assert w_bitmap is not w_wordbmp
assert isinstance(w_bitmap, W_DisplayBitmap)
sdldisplay = w_bitmap.display()
assert isinstance(sdldisplay, display.SDLDisplay)
mock_display2 = W_PointersObject(space, space.w_Point, 4)
mock_display2.store(space, 0, W_WordsObject(space, space.w_Bitmap, 10)) # bitmap
mock_display2.store(space, 1, space.wrap_int(32)) # width
mock_display2.store(space, 2, space.wrap_int(10)) # height
mock_display2.store(space, 3, space.wrap_int(1)) # depth
prim(BE_DISPLAY, [mock_display2])
assert space.w_display() is mock_display2
w_bitmap2 = mock_display.fetch(space, 0)
assert isinstance(w_bitmap2, W_DisplayBitmap)
assert w_bitmap.display() is w_bitmap2.display()
assert sdldisplay.width == 32
assert sdldisplay.height == 10
prim(BE_DISPLAY, [mock_display])
assert space.w_display() is mock_display
assert mock_display.fetch(space, 0) is w_bitmap
def test_contextOn_do_():
"""
contextOn:do: is some very heavy meta programming. It creates and returns a separate stack frame,
settings it's sender to nil, thereby manipulating the senders of two contexts.
The Point in there should actually be UnhandledError or something.
The test here is just that this works.
ctx := ContextPart contextOn: Point do: ['nothing']
"""
ContextPart = space.w_MethodContext.as_class_get_shadow(space).s_superclass().w_self()
ContextPartClass = ContextPart.getclass(space).as_class_get_shadow(space).w_self()
contextOnDo = find_symbol("contextOn:do:", ContextPartClass)
bytes = [
0x42, 0x43, # Push the classes
0x8f, 0x00, 0x00, 0x02, # Push block,
0x24, 0x7d, # in the block
0xf1, 0x81, 0xc0, 0x7c # Send contextOn:do:
]
Association = space.w_Point # Wrong class, doesn't matter.
ctxAssoc = W_PointersObject(space, Association, 2)
ctxAssoc.store(space, 0, w('ctx'))
ctxAssoc.store(space, 1, space.w_nil)
contextPartAssoc = W_PointersObject(space, Association, 2)
contextPartAssoc.store(space, 0, w('ContextPart'))
contextPartAssoc.store(space, 1, ContextPart)
errorAssoc = W_PointersObject(space, Association, 2)
errorAssoc.store(space, 0, w('Point'))
errorAssoc.store(space, 1, Association)
w_method = space.make_method(bytes, [ctxAssoc, contextOnDo, contextPartAssoc, errorAssoc, w('nothing')])
result = interp.execute_method(w_method)
assert isinstance(result, W_PointersObject)
s = result.as_context_get_shadow(space)
assert s.w_method().lookup_selector == "on:do:"
assert s.w_method().primitive() == 199
assert s.s_sender() == None
def initialize_methoddict(self):
if self._s_methoddict is None:
w_methoddict = W_PointersObject(self.space, None, 2)
w_methoddict.store(self.space, constants.METHODDICT_VALUES_INDEX, W_PointersObject(self.space, None, 0))
self.store_s_methoddict(w_methoddict.as_methoddict_get_shadow(self.space))
def func(interp, s_frame, w_rcvr):
x, y = interp.space.display().mouse_point()
w_point = W_PointersObject(interp.space, interp.space.w_Point, 2)
w_point.store(interp.space, 0, interp.space.wrap_int(x))
w_point.store(interp.space, 1, interp.space.wrap_int(y))
return w_point