def test_stacking_interpreter():
# | testBlock |
# testBlock := [ :aNumber |
# aNumber = 0
# ifTrue: [ 0 ]
# ifFalse: [ (testBlock value: aNumber - 1) + aNumber ]].
# ^ testBlock value: 11
import operator
interp = interpreter.Interpreter(space, max_stack_depth=3)
#create a method with the correct bytecodes and a literal
bytes = reduce(
operator.add,
map(chr, [
0x8a, 0x01, 0x68, 0x10, 0x8f, 0x11, 0x00, 0x11, 0x10, 0x75, 0xb6,
0x9a, 0x75, 0xa4, 0x09, 0x8c, 0x00, 0x01, 0x10, 0x76, 0xb1, 0xca,
0x10, 0xb0, 0x7d, 0x8e, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x20, 0xca,
0x7c
]))
w_method = model.W_CompiledMethod(len(bytes))
w_method.islarge = 1
w_method.bytes = bytes
w_method.argsize = 0
w_method.tempsize = 1
w_method.setliterals([space.wrap_int(11)])
#create a frame for that method
w_frame = w_method.as_compiledmethod_get_shadow(space).create_frame(
space, space.wrap_int(0), []).w_self()
try:
interp.loop(w_frame)
except interpreter.ReturnFromTopLevel, e:
assert space.unwrap_int(e.object) == 66
def mock(stack, context = None):
mapped_stack = [wrap(x) for x in stack]
if context is None:
frame = MockFrame(mapped_stack)
else:
frame = context
for i in range(len(stack)):
frame.as_context_get_shadow(space).push(stack[i])
interp = interpreter.Interpreter(space, image_name=IMAGENAME)
return (interp, frame, len(stack))
def setup_module(module, filename='mini.image'):
space = objspace.ObjSpace()
from spyvm.tool.analyseimage import image_dir
module.mini_image = image_dir.join(filename)
module.reader = open_miniimage(space)
reader.initialize()
module.image = squeakimage.SqueakImage()
module.image.from_reader(space, reader)
module.space = space
module.interp = interpreter.Interpreter(space, image)
return space, module.interp
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 test_runimage():
py.test.skip(
"This method actually runs an image. Fails since no graphical primitives yet"
)
from spyvm import wrapper
ap = wrapper.ProcessWrapper(space,
wrapper.scheduler(space).active_process())
w_ctx = ap.suspended_context()
ap.store_suspended_context(space.w_nil)
interp = interpreter.Interpreter(space)
interp.interpret_with_w_frame(w_ctx)
def build_up_closure_environment(args, copiedValues=[]):
from test_interpreter import new_frame
w_frame, s_initial_context = new_frame("<never called, but used for method generation>",
space=space)
size_arguments = len(args)
closure = space.newClosure(w_frame, 4, #pc
size_arguments, copiedValues)
s_initial_context.push_all([closure] + args)
interp = interpreter.Interpreter(space)
s_active_context = prim_table[primitives.CLOSURE_VALUE + size_arguments](interp, s_initial_context, size_arguments)
return s_initial_context, closure, s_active_context
def test_miniloop(self):
from spyvm import objspace
space = objspace.ObjSpace()
image = create_testimage(space)
interp = interpreter.Interpreter(space, image)
w_selector = interp.perform(space.wrap_string('loopTest2'), "asSymbol")
assert isinstance(w_selector, model.W_BytesObject)
def interp_w():
interp.perform(model.W_SmallInteger(1000), w_selector)
self.meta_interp(interp_w, [], listcomp=True, listops=True, backendopt=True, inline=True)
def test_primitive_next_instance_wo_some_instance_in_same_frame():
someInstances = map(space.wrap_list, [[2], [3]])
from test_interpreter import new_frame
w_frame, s_context = new_frame("<never called, but needed for method generation>",
space=space)
s_context.push(space.w_Array)
interp = interpreter.Interpreter(space)
w_1 = someInstances[0]
assert w_1.getclass(space) is space.w_Array
s_context.push(w_1)
prim_table[primitives.NEXT_INSTANCE](interp, s_context, 0)
w_2 = s_context.pop()
assert w_2.getclass(space) is space.w_Array
assert w_1 is not w_2
def test_step_run_something():
from spyvm.test import test_miniimage
setup_module(test_miniimage, filename='running-something-mini.image')
from spyvm import wrapper
ap = wrapper.ProcessWrapper(space,
wrapper.scheduler(space).active_process())
w_ctx = ap.suspended_context()
s_ctx = w_ctx.as_context_get_shadow(space)
ap.store_suspended_context(space.w_nil)
interp = interpreter.Interpreter(space)
assert isinstance(s_ctx, shadow.MethodContextShadow)
assert s_ctx.top().is_same_object(space.w_true)
interp.step(s_ctx)
interp.step(s_ctx)
assert s_ctx.top().value == 1
interp.step(s_ctx)
assert s_ctx.top().value == 2
interp.step(s_ctx)
assert s_ctx.top().value == 3
def test_primitive_value_no_context_switch(monkeypatch):
class Context_switched(Exception):
pass
class Stepping(Exception):
pass
def quick_check_for_interrupt(s_frame, dec=1):
raise Context_switched
def step(s_frame):
raise Stepping
from test_interpreter import new_frame
w_frame, s_initial_context = new_frame("<never called, but used for method generation>",
space=space)
closure = space.newClosure(w_frame, 4, 0, [])
s_frame = w_frame.as_methodcontext_get_shadow(space)
interp = interpreter.Interpreter(space, image_name=IMAGENAME)
interp._loop = True
try:
monkeypatch.setattr(interp, "quick_check_for_interrupt", quick_check_for_interrupt)
monkeypatch.setattr(interp, "step", step)
try:
s_frame.push(closure)
prim_table[primitives.CLOSURE_VALUE](interp, s_frame, 0)
except Context_switched:
assert True
except Stepping:
assert False
try:
s_frame.push(closure)
prim_table[primitives.CLOSURE_VALUE_NO_CONTEXT_SWITCH](interp, s_frame, 0)
except Context_switched:
assert False
except Stepping:
assert True
finally:
monkeypatch.undo()
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 entry_point(argv):
# == Main execution parameters
path = None
selector = None
code = ""
number = 0
have_number = False
stringarg = None
headless = True
# == Other parameters
poll = False
interrupts = True
trace = False
trace_important = False
space = prebuilt_space
idx = 1
try:
while idx < len(argv):
arg = argv[idx]
idx += 1
if arg in ["-h", "--help"]:
_usage(argv)
return 0
elif arg in ["-j", "--jit"]:
jitarg, idx = get_parameter(argv, idx, arg)
jit.set_user_param(interpreter.Interpreter.jit_driver, jitarg)
elif arg in ["-n", "--number"]:
number, idx = get_int_parameter(argv, idx, arg)
have_number = True
elif arg in ["-m", "--method"]:
selector, idx = get_parameter(argv, idx, arg)
elif arg in ["-t", "--trace"]:
trace = True
elif arg in ["-T"]:
trace_important = True
elif arg in ["-s", "--safe-trace"]:
space.omit_printing_raw_bytes.activate()
elif arg in ["-p", "--poll"]:
poll = True
elif arg in ["-a", "--arg"]:
stringarg, idx = get_parameter(argv, idx, arg)
elif arg in ["-r", "--run"]:
code, idx = get_parameter(argv, idx, arg)
elif arg in ["-i", "--no-interrupts"]:
interrupts = False
elif arg in ["-P", "--process"]:
headless = False
elif arg in ["--hacks"]:
space.run_spy_hacks.activate()
elif arg in ["-S"]:
space.strategy_factory.no_specialized_storage.activate()
elif arg in ["-u"]:
from spyvm.plugins.vmdebugging import stop_ui_process
stop_ui_process()
elif arg in ["-l", "--storage-log"]:
space.strategy_factory.logger.activate()
elif arg in ["-L", "--storage-log-aggregate"]:
space.strategy_factory.logger.activate(aggregate=True)
elif path is None:
path = arg
else:
_usage(argv)
return -1
if path is None:
path = "Squeak.image"
if code and selector:
raise error.Exit("Cannot handle both -r and -m.")
except error.Exit as e:
print_error("Parameter error: %s" % e.msg)
return 1
path = rpath.rabspath(path)
try:
stream = squeakimage.Stream(filename=path)
except OSError as e:
print_error("%s -- %s (LoadError)" % (os.strerror(e.errno), path))
return 1
# Load & prepare image and environment
image = squeakimage.ImageReader(space, stream).create_image()
interp = interpreter.Interpreter(space, image,
trace=trace, trace_important=trace_important,
evented=not poll, interrupts=interrupts)
space.runtime_setup(argv[0], path)
print_error("") # Line break after image-loading characters
# Create context to be executed
if code or selector:
if not have_number:
w_receiver = space.w_nil
else:
w_receiver = space.wrap_int(number)
if code:
selector = compile_code(interp, w_receiver, code)
s_frame = create_context(interp, w_receiver, selector, stringarg)
if headless:
space.headless.activate()
context = s_frame
else:
create_process(interp, s_frame)
context = active_context(space)
else:
context = active_context(space)
w_result = execute_context(interp, context)
print result_string(w_result)
return 0
from spyvm import objspace, wrapper, constants
def mockclass(space,
instsize,
w_superclass=None,
w_metaclass=None,
name='?',
format=shadow.POINTERS,
varsized=True):
return objspace.bootstrap_class(space, instsize, w_superclass, w_metaclass,
name, format, varsized)
space = objspace.ObjSpace()
interp = interpreter.Interpreter(space)
def step_in_interp(ctxt): # due to missing resets in between tests
interp._loop = False
try:
retval = interp.step(ctxt)
if retval is not None:
return retval.w_self()
except interpreter.Return, nlr:
nlr.s_target_context.push(nlr.value)
return nlr.s_target_context.w_self()
# expose the bytecode's values as global constants.
# Bytecodes that have a whole range are exposed as global functions:
def entry_point(argv):
idx = 1
path = None
number = 0
benchmark = None
trace = False
evented = True
stringarg = ""
code = None
as_benchmark = False
while idx < len(argv):
arg = argv[idx]
if arg in ["-h", "--help"]:
_usage(argv)
return 0
elif arg in ["-j", "--jit"]:
_arg_missing(argv, idx, arg)
jitarg = argv[idx + 1]
idx += 1
jit.set_user_param(interpreter.Interpreter.jit_driver, jitarg)
elif arg in ["-n", "--number"]:
_arg_missing(argv, idx, arg)
number = int(argv[idx + 1])
idx += 1
elif arg in ["-m", "--method"]:
_arg_missing(argv, idx, arg)
benchmark = argv[idx + 1]
idx += 1
elif arg in ["-t", "--trace"]:
trace = True
elif arg in ["-p", "--poll_events"]:
evented = False
elif arg in ["-a", "--arg"]:
_arg_missing(argv, idx, arg)
stringarg = argv[idx + 1]
idx += 1
elif arg in ["-r", "--run"]:
_arg_missing(argv, idx, arg)
code = argv[idx + 1]
as_benchmark = False
idx += 1
elif arg in ["-b", "--benchmark"]:
_arg_missing(argv, idx, arg)
code = argv[idx + 1]
as_benchmark = True
idx += 1
elif path is None:
path = argv[idx]
else:
_usage(argv)
return -1
idx += 1
if path is None:
path = "Squeak.image"
path = rpath.rabspath(path)
try:
f = open_file_as_stream(path, mode="rb", buffering=0)
except OSError as e:
os.write(2, "%s -- %s (LoadError)\n" % (os.strerror(e.errno), path))
return 1
try:
imagedata = f.readall()
finally:
f.close()
image_reader = squeakimage.reader_for_image(
space, squeakimage.Stream(data=imagedata))
image = create_image(space, image_reader)
interp = interpreter.Interpreter(space,
image,
image_name=path,
trace=trace,
evented=evented)
space.runtime_setup(argv[0])
if benchmark is not None:
return _run_benchmark(interp, number, benchmark, stringarg)
elif code is not None:
return _run_code(interp, code, as_benchmark=as_benchmark)
else:
_run_image(interp)
return 0
