def test_loop(self):
source = """
(|
benchmark = (| i <- 0. |
[i < 1000] whileTrue: [
i: i + 1.
].
).
|) benchmark.
"""
universe = Object()
universe.meta_add_slot("primitives", get_primitives())
interpreter = Interpreter(universe)
run_stdlib(interpreter, stdlib_source)
ast = lex_and_parse_as_root(source)
if not ast:
return None, interpreter
code = ast.compile(CodeContext())
interpreter.add_process(code.finalize())
def f():
interpreter.interpret()
return 0
#res = f()
#assert res == 0
res = self.meta_interp(f, [],
listops=True,
listcomp=True,
backendopt=True)
assert res == 0
def __init__(self, obj_to_mirror, obj_map=None):
Object.__init__(self, obj_map)
assert isinstance(obj_to_mirror, Object)
self.obj_to_mirror = obj_to_mirror
add_primitive_fn(self, "toSlot:Add:", primitive_add_slot,
["name", "obj"])
def test_meta_add_parent_cloned_objects_use_same_map():
o = Object()
o.meta_add_parent("a", PrimitiveStrObject("value"))
x = o.clone()
assert "a" in o.parent_slot_keys
assert o.map == x.map
def test_meta_add_slot():
val = PrimitiveStrObject("xe")
o = Object()
assert not o._slot_values
o.meta_add_slot("test", val)
assert o._slot_values[0] == val
def test_meta_add_parent():
val = Object()
o = Object()
o.meta_add_parent("p*", val)
assert "p*" in o.map._parent_slots
assert val in o._parent_slot_values
def test_meta_add_parent_structural_change_creates_new_map_add():
o = Object()
o.meta_add_parent("a", PrimitiveStrObject("value"))
x = o.clone()
assert o.map == x.map
x.meta_add_parent("*", PrimitiveStrObject("another"))
assert o.map != x.map
assert o != x
def test_get_slot_from_one_parent():
val = PrimitiveStrObject("it is xex!")
p = Object()
p.meta_add_slot("xex", val)
o = Object()
o.meta_add_parent("p", p)
assert o.get_slot("xex") is None
assert o.parent_lookup("xex") is val
def test_meta_add_parent_cloned_objects_dont_change_when_parent_is_changed():
o = Object()
o.meta_add_parent("a", PrimitiveStrObject("value"))
x = o.clone()
assert o.map == x.map
x.meta_add_parent("a", PrimitiveStrObject("another"))
assert o.map == x.map
assert o != x
def test_meta_add_parent_structural_change_creates_new_map_remove():
o = Object()
o.meta_add_parent("a", PrimitiveStrObject("value"))
x = o.clone()
assert o.map == x.map
x.meta_remove_parent("a")
assert o.map != x.map
assert o != x
assert "a" in o.parent_slot_keys
def _add_reflection_to_universe(self):
self.universe.meta_add_slot("universe", self.universe)
primitives = self.universe.get_slot("primitives")
if primitives is None:
primitives = Object()
self.universe.meta_add_slot("primitives", primitives)
# transport values from primitives to global level
for slot in primitives.slot_keys:
self.universe.meta_add_slot(slot, primitives.get_slot(slot))
primitives.meta_add_slot("interpreter", gen_interpreter_primitives(self))
def test_slot_lookup_from_scope_parent():
p = Object()
val = PrimitiveStrObject("it is xex!")
p.meta_add_slot("xex", val)
o = Object()
o.scope_parent = p
assert o.get_slot("xex") is None
assert o.slot_lookup("xex") is val
def test_mirror():
o = Object()
m = Mirror(o)
assert not o.slot_lookup("v")
add_primitive = m.slot_lookup("toSlot:Add:")
assert add_primitive.map.primitive_code
result = add_primitive.map.primitive_code(
None, m, [PrimitiveStrObject("v"),
PrimitiveIntObject(1)])
assert result == o
assert o.slot_lookup("v") == PrimitiveIntObject(1)
def test_running_self_unittest_file():
universe = Object()
universe.meta_add_slot("primitives", get_primitives())
dirname = os.path.dirname(__file__)
source_file_path = os.path.join(dirname, "..", "scripts", "unittest.self")
with open(source_file_path) as source_file:
ast = lex_and_parse(source_file.read())
interpreter = Interpreter(universe)
for item in ast:
process = interpreter.add_process(item.compile(CodeContext()))
interpreter.interpret()
assert process.finished
assert not process.finished_with_error
def test_is_assignment_primitive():
o = Object()
assert not o.is_assignment_primitive
o = AssignmentPrimitive()
assert o.is_assignment_primitive
assert not o.has_code
def build_primitive_code_obj(primitive_fn, arguments):
code_obj = Object()
code_obj.map.arguments = arguments
code_obj.map.primitive_code = primitive_fn
return code_obj
def compile(self, context):
obj = ObjectRepresentation()
obj.meta_set_ast(self)
obj.meta_set_parameters(self.params)
index = context.add_literal_obj(obj)
context.add_bytecode(BYTECODE_PUSH_LITERAL)
context.add_bytecode(LITERAL_TYPE_OBJ)
context.add_bytecode(index)
for name, value in self.slots.iteritems():
self._add_slot_to_bytecode(context, name, value)
context.add_bytecode(SLOT_NORMAL)
for name, value in self.parents.iteritems():
self._add_slot_to_bytecode(context, name, value)
context.add_bytecode(SLOT_PARENT)
if self.code:
new_context = CodeContext()
obj.meta_set_code_context(new_context)
for item in self.code:
item.compile(new_context)
obj.map.code_context = new_context
return context
def compile(self, context):
block = ObjectRepresentation()
block.meta_set_ast(self)
block.meta_set_parameters(self.params)
# push current scope
context.add_bytecode(BYTECODE_PUSH_SELF)
index = context.add_literal_obj(block)
context.add_bytecode(BYTECODE_PUSH_LITERAL)
context.add_bytecode(LITERAL_TYPE_BLOCK)
context.add_bytecode(index)
for name, value in self.slots.iteritems():
self._add_slot_to_bytecode(context, name, value)
context.add_bytecode(SLOT_NORMAL)
for name, value in self.parents.iteritems():
self._add_slot_to_bytecode(context, name, value)
context.add_bytecode(SLOT_PARENT)
new_context = CodeContext()
block.meta_set_code_context(new_context)
for item in self.code:
item.compile(new_context)
block.map.code_context = new_context
return context
def test_has_primitive_code():
o = Object()
assert not o.has_primitive_code
def test(x):
return x
o.map.primitive_code = test
assert o.has_primitive_code
assert not o.is_assignment_primitive
def virtual_machine(source, stdlib_source=""):
universe = Object()
universe.meta_add_slot("primitives", get_primitives())
interpreter = Interpreter(universe)
if stdlib_source:
if not run_stdlib(interpreter, stdlib_source):
return None, interpreter
ast = lex_and_parse_as_root(source)
if not ast:
return None, interpreter
code = ast.compile(CodeContext())
process = interpreter.add_process(code.finalize())
interpreter.interpret()
return process, interpreter
def test_meta_insert_slot():
first = PrimitiveStrObject("first")
second = PrimitiveStrObject("second")
third = PrimitiveStrObject("third")
o = Object()
assert not o._slot_values
o.meta_add_slot("first", first)
o.meta_add_slot("third", third)
assert o.get_slot("first") is first
assert o.get_slot("third") is third
o.meta_insert_slot(1, "second", second)
assert o.map._slots.keys() == ["first", "second", "third"]
# make sure that objects didn't shifted
assert o.get_slot("first") is first
assert o.get_slot("second") is second
assert o.get_slot("third") is third
def test_meta_remove_slot():
o = Object()
assert not o._slot_values
o.meta_add_slot("test", Object())
assert o._slot_values
assert "test" in o.map._slots
o.meta_remove_slot("test")
assert not o._slot_values
assert "test" not in o.map._slots
def _run_script(interpreter, scope_parent, parameters):
path = parameters[0]
assert isinstance(path, Object)
if not isinstance(path, PrimitiveStrObject):
return _raise_error(
interpreter,
scope_parent,
[PrimitiveStrObject("runScript: str parameter expected")]
)
try:
with open(path.value) as f:
source = f.read()
except Exception as e:
return _raise_error(
interpreter,
scope_parent,
[PrimitiveStrObject("runScript: %s" % str(e))]
)
ast_root = lex_and_parse_as_root(source)
if not ast_root.ast:
return
code = ast_root.compile(CodeContext())
code.finalize()
method_obj = Object()
method_obj.code_context = code
interpreter._push_code_obj_for_interpretation(
next_bytecode=0, # disable TCO
scope_parent=scope_parent,
method_obj=method_obj,
parameters=[],
)
def test_process_stack_push_frame_behavior():
ps = ProcessStack()
ps.frame.push(PrimitiveIntObject(1))
assert not ps.is_nested_call()
cc = CodeContext()
method = Object()
ps.push_frame(cc, method)
assert ps.is_nested_call()
assert ps.frame.code_context == cc
retval = Object()
ps.frame.push(retval)
assert ps._length == 2
assert ps.frame._stack.obj == retval
assert ps.frame.prev_stack._stack.obj != retval
ps.pop_down_and_cleanup_frame()
assert ps._length == 1
assert ps.frame._stack.obj == retval
assert ps.frame.prev_stack is None
def test_clone():
o = Object()
o.meta_add_slot("test", Object())
# clones share same map
clone = o.clone()
assert clone.map is o.map
assert clone._slot_values == o._slot_values
# clones with updated slot value share same map
clone.set_slot("test", Object())
assert clone.map is o.map
assert clone._slot_values != o._slot_values
# clones with different structure don't share maps
clone.meta_add_slot("another", Object())
assert clone.map is not o.map
assert clone._slot_values != o._slot_values
def test_meta_remove_parent():
a_slot = PrimitiveStrObject("value a")
b_slot = PrimitiveStrObject("value b")
o = Object()
o.meta_add_parent("a", a_slot)
o.meta_add_parent("b", b_slot)
assert "a" in o.parent_slot_keys
assert "b" in o.parent_slot_keys
assert o.meta_get_parent("a") is a_slot
assert o.meta_get_parent("b") is b_slot
o.meta_remove_parent("a")
assert o.meta_get_parent("b") is b_slot
assert len(o._parent_slot_values) == 1
def test_meta_add_slot_do_check_duplicates():
xx = PrimitiveStrObject("xx")
zz = PrimitiveStrObject("zz")
o = Object()
assert not o._slot_values
o.meta_add_slot("xx", xx)
o.meta_add_slot("zz", zz)
assert len(o._slot_values) == 2
o.meta_add_slot("xx2", xx, check_duplicates=True)
assert len(o._slot_values) == 2
def gen_interpreter_primitives(interpreter):
interpreter_namespace = Object()
add_primitive_method(interpreter, interpreter_namespace, "numberOfProcesses",
_get_number_of_processes, [])
add_primitive_method(interpreter, interpreter_namespace, "numberOfFrames",
_get_number_of_stack_frames, [])
add_primitive_method(interpreter, interpreter_namespace, "setErrorHandler:",
_set_error_handler, ["blck"])
add_primitive_method(interpreter, interpreter_namespace, "error:",
_raise_error, ["obj"])
add_primitive_method(interpreter, interpreter_namespace, "halt:",
_halt, ["obj"])
add_primitive_method(interpreter, interpreter_namespace, "restoreProcess:",
_restore_process, ["err_obj"])
add_primitive_method(interpreter, interpreter_namespace, "restoreProcess:With:",
_restore_process_with, ["msg", "err_obj"])
add_primitive_method(interpreter, interpreter_namespace, "runScript:",
_run_script, ["path"])
return interpreter_namespace
def __init__(self, obj_map=None):
Object.__init__(self, obj_map)
def __init__(self):
Object.__init__(self)
add_primitive_fn(self, "is:", is_false, ["obj"])
def __init__(self, message, process_stack):
Object.__init__(self)
self.message = message
self.process_stack = process_stack
