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