def execute(self):
source = self.instruction.pos
value = self.peek_op_stack()
switch = self.switch_class.from_instruction(self.instruction)
offset = switch.find_offset(value.value)
target = source + offset
return Actions(actions.Pop(), actions.GoTo(target))
def execute(self):
field_ref = self.operand_as_constant()
field_name = field_name_from_field_ref(field_ref)
class_name = field_ref.class_.name.value
value = self.peek_op_stack()
return IncrementProgramCounter.after(
actions.Pop(), actions.PutStatic(class_name, field_name, value))
def execute(self):
ops = reversed(list(self.peek_many(self.ops)))
value = self.op(*(op.value for op in ops))
result = self.type.create_instance(value)
return IncrementProgramCounter.after(
actions.Pop(self.ops),
actions.Push(result)
)
def execute(self):
array = self.peek_op_stack()
if array.is_null:
return actions.throw_null_pointer()
else:
size = len(array.value)
result = Integer.create_instance(size)
return IncrementProgramCounter.after(actions.Pop(),
actions.Push(result))
def execute(self):
field_ref = self.operand_as_constant()
name = field_name_from_field_ref(field_ref)
obj = self.peek_op_stack()
if obj.is_null:
return actions.throw_null_pointer()
value = obj.value.fields[name]
return IncrementProgramCounter.after(actions.Pop(),
actions.Push(value))
def execute(self):
values = self._get_values()
result = self.op(*values)
if result:
offset = self.operand_as_int()
else:
offset = 1
target = self.instruction.pos + offset
return Actions(actions.Pop(self.pops), actions.GoTo(target))
def execute(self):
index = self.peek_op_stack()
array = self.peek_op_stack(1)
if array.is_null:
return actions.throw_null_pointer()
value = array.value[index.value]
return IncrementProgramCounter.after(
actions.Pop(2),
actions.Push(value)
)
def execute(self):
field_ref = self.operand_as_constant()
name = field_name_from_field_ref(field_ref)
value = self.peek_op_stack(0)
obj = self.peek_op_stack(1)
if obj.is_null:
return actions.throw_null_pointer()
return IncrementProgramCounter.after(
actions.Pop(2), actions.PutField(obj, name, value))
def execute(self):
type_ = self._get_type()
size = self.peek_op_stack().value
if size < 0:
return actions.throw_negative_array_size()
else:
elements = [
type_.create_instance(type_.default_value) for _ in range(size)
]
result = ArrayReferenceType(type_).create_instance(elements)
return IncrementProgramCounter.after(actions.Pop(),
actions.Push(result))
def execute(self):
method_ref = self.operand_as_constant()
class_name = method_ref.class_.name.value
key = key_from_method_ref(method_ref)
class_ = self.loader.get_the_class(class_name)
method = class_.methods[key]
num_args = len(method.args) + self.args_to_add
args = reversed(self.peek_many(num_args))
return Actions(
actions.Pop(num_args),
actions.Invoke(class_name, key, args)
)
def execute(self):
constant_index = self.operand_as_int()
constant = self.constants[constant_index]
class_name = constant.name.value
obj = self.peek_op_stack()
if obj.is_null:
answer = False
else:
answer = is_value_instance_of(obj, class_as_descriptor(class_name),
self.loader)
if answer:
result = Integer.create_instance(1)
else:
result = Integer.create_instance(0)
return IncrementProgramCounter.after(actions.Pop(),
actions.Push(result))
def execute(self):
class_ = self.operand_as_constant()
class_name = class_.name.value
base_type = ObjectReferenceType(class_name)
num_dimensions = self.operand_as_int(index=1)
dimensions = [v.value for v in self.peek_many(num_dimensions)]
if any(d < 0 for d in dimensions):
return actions.throw_negative_array_size()
array_type = base_type
for _ in range(num_dimensions):
array_type = ArrayReferenceType(array_type)
array_value = create_levels(
dimensions,
lambda: base_type.create_instance(base_type.default_value))
return IncrementProgramCounter.after(
actions.Pop(num_dimensions),
actions.Push(array_type.create_instance(array_value)))
def execute(self):
value = self.peek_op_stack().value
converted = self.target.create_instance(value)
return IncrementProgramCounter.after(actions.Pop(),
actions.Push(converted))
def execute(self):
return IncrementProgramCounter.after(
actions.Pop(2), actions.Push(self.peek_op_stack(0)),
actions.Push(self.peek_op_stack(1)))
def execute(self):
return IncrementProgramCounter.after(actions.Pop(self.amount))
def execute(self):
values = (value.value for value in self.peek_many(2))
bool_result = self.op(*values)
num_result = bool_to_num(bool_result)
return IncrementProgramCounter.after(actions.Pop(2),
actions.Push(num_result))
