def test_PrimitiveIntObject_as_primitive_string():
o = PrimitiveIntObject(2)
plus_slot = o.slot_lookup("asString")
assert plus_slot.map.primitive_code
result = plus_slot.map.primitive_code(None, o, [])
assert result == PrimitiveStrObject("2")
def test_parallelism():
one_plus_one_ast = lex_and_parse("""(|
add = (|| 1 + 1)
|) add""")
two_plus_two_ast = lex_and_parse("""(|
add = (|| 2 + 2)
|) add""")
one_plus_one_ctx = one_plus_one_ast[0].compile(CodeContext())
two_plus_two_ctx = two_plus_two_ast[0].compile(CodeContext())
interpreter = Interpreter(universe=get_primitives())
one_plus_one_process = interpreter.add_process(one_plus_one_ctx)
two_plus_two_process = interpreter.add_process(two_plus_two_ctx)
assert not one_plus_one_process.finished
assert not one_plus_one_process.result
assert not two_plus_two_process.finished
assert not two_plus_two_process.result
interpreter.interpret()
assert one_plus_one_process.finished
assert one_plus_one_process.result == PrimitiveIntObject(2)
assert two_plus_two_process.finished
assert two_plus_two_process.result == PrimitiveIntObject(4)
def call_primitive_int_binary_op(first, op, second, equals):
o = PrimitiveIntObject(first)
if isinstance(equals, (int, long)):
equals = PrimitiveIntObject(equals)
primitive_slot = o.slot_lookup(op)
assert primitive_slot.map.primitive_code
result = primitive_slot.map.primitive_code(None, o,
[PrimitiveIntObject(second)])
assert result == equals
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 _do_push_literal(self, bc_index, code_obj):
literal_type = ord(code_obj.bytecodes[bc_index + 1])
literal_index = ord(code_obj.bytecodes[bc_index + 2])
boxed_literal = code_obj.literals[literal_index]
if literal_type == LITERAL_TYPE_NIL:
obj = NIL
elif literal_type == LITERAL_TYPE_ASSIGNMENT:
obj = AssignmentPrimitive()
elif literal_type == LITERAL_TYPE_INT:
assert isinstance(boxed_literal, IntBox)
obj = PrimitiveIntObject(boxed_literal.value)
elif literal_type == LITERAL_TYPE_FLOAT:
assert isinstance(boxed_literal, FloatBox)
obj = PrimitiveFloatObject(boxed_literal.value)
elif literal_type == LITERAL_TYPE_STR:
assert isinstance(boxed_literal, StrBox)
obj = PrimitiveStrObject(boxed_literal.value)
elif literal_type == LITERAL_TYPE_OBJ:
assert isinstance(boxed_literal, ObjBox)
obj = boxed_literal.value.clone()
if self.process.frame.self is None:
self.process.frame.self = obj
elif literal_type == LITERAL_TYPE_BLOCK:
assert isinstance(boxed_literal, ObjBox)
block = boxed_literal.value.clone()
obj = add_block_trait(block)
block.is_block = True
block.scope_parent = self.process.frame.pop()
else:
raise ValueError("Unknown literal type; %s" % literal_type)
self.process.frame.push(obj)
return THREE_BYTECODES_LONG
def test_interpreter():
ast = lex_and_parse("""(|
a <- 1.
add: b = (||
(a + 1) + b
)
|) add: 2""")
context = ast[0].compile(CodeContext())
interpreter = Interpreter(universe=get_primitives(), code_context=context)
interpreter.interpret()
assert interpreter.process.result == PrimitiveIntObject(4)
def test_resend_keyword():
ast = lex_and_parse("""(|
p* = (| xex: a = (|| 1). |).
q* = (| xex: a = (|| a). |).
fetchXex = (|| q.xex: 2)
|) fetchXex""")
context = ast[0].compile(CodeContext())
interpreter = Interpreter(universe=get_primitives(), code_context=context)
interpreter.interpret()
assert interpreter.process.result == PrimitiveIntObject(2)
def test_PrimitiveNilObject_equals():
o = PrimitiveNilObject()
eq_slot = o.slot_lookup("==")
result = eq_slot.map.primitive_code(None, o, [PrimitiveNilObject()])
assert result == PrimitiveTrueObject()
eq_slot = o.slot_lookup("==")
result = eq_slot.map.primitive_code(None, o, [PrimitiveIntObject(3)])
assert result == PrimitiveFalseObject()
eq_slot = o.slot_lookup("==")
result = eq_slot.map.primitive_code(None, o, [PrimitiveTrueObject()])
assert result == PrimitiveFalseObject()
def test_PrimitiveFalseObject_is():
o = PrimitiveFalseObject()
is_slot = o.slot_lookup("is:")
result = is_slot.map.primitive_code(None, o, [PrimitiveFalseObject()])
assert result == PrimitiveTrueObject()
is_slot = o.slot_lookup("is:")
result = is_slot.map.primitive_code(None, o, [PrimitiveIntObject(3)])
assert result == PrimitiveFalseObject()
is_slot = o.slot_lookup("is:")
result = is_slot.map.primitive_code(None, o, [PrimitiveTrueObject()])
assert result == PrimitiveFalseObject()
def test_assignment_primitive():
ast = lex_and_parse("""(|
a <- 0.
incA = (||
a: 1.
^a
)
|) incA""")
context = ast[0].compile(CodeContext())
interpreter = Interpreter(universe=get_primitives(), code_context=context)
interpreter.interpret()
assert interpreter.process.result == PrimitiveIntObject(1)
def test_set_error_handler_and_handle_error():
ast = lex_and_parse("""(|
raiseError = (|| primitives interpreter error: 'Test'.).
test = (||
primitives interpreter setErrorHandler: [:msg. :err |
primitives interpreter restoreProcess: err With: 1.
].
^ 1 + raiseError.
)
|) test""")
context = ast[0].compile(CodeContext())
interpreter = Interpreter(universe=get_primitives(), code_context=context)
interpreter.interpret()
assert interpreter.process.finished
assert not interpreter.process.finished_with_error
result = interpreter.process.result
assert result == PrimitiveIntObject(2)
def test_block_with_argument():
ast = lex_and_parse("""(|
a <- 0.
giveOneToBlock: blk = (||
blk with: 1
).
shouldBeThree = (| tmp = 1. block. |
block: [| :x | a + tmp + x].
a: 1.
giveOneToBlock: block.
)
|) shouldBeThree""")
context = ast[0].compile(CodeContext())
interpreter = Interpreter(universe=get_primitives(), code_context=context)
interpreter.interpret()
assert interpreter.process.result == PrimitiveIntObject(3)
def test_block():
ast = lex_and_parse("""(|
a <- 0.
addTenToBlk: blk = (||
10 + (blk value).
).
add = (| tmp = 3. tmp_block. |
tmp_block: [a + tmp].
a: 1. # block should reflect current scopes
2 + addTenToBlk: tmp_block.
)
|) add""")
context = ast[0].compile(CodeContext())
interpreter = Interpreter(universe=get_primitives(), code_context=context)
interpreter.interpret()
assert interpreter.process.result == PrimitiveIntObject(16)
def test_method_stack():
f = MethodStack()
f.push(PrimitiveIntObject(1))
f.push(PrimitiveIntObject(2))
assert f.pop() == PrimitiveIntObject(2)
assert f.pop() == PrimitiveIntObject(1)
with raises(IndexError):
f.pop()
assert f.pop_or_nil() == NIL
f.push(PrimitiveIntObject(1))
assert f.pop_or_nil() == PrimitiveIntObject(1)
assert f.pop_or_nil() == NIL
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 _get_number_of_stack_frames(interpreter, _, parameters):
return PrimitiveIntObject(interpreter.process._length)
def _get_number_of_processes(interpreter, _, parameters):
return PrimitiveIntObject(len(interpreter.processes))
