Optimizations for GDScript VM
* Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
This commit is contained in:
Juan Linietsky
parent
57267709e6
commit
7211e041df
|
|
@ -183,7 +183,7 @@ GDScriptFunction *GDScriptByteCodeGenerator::write_end() {
|
|||
ERR_PRINT("Non-zero temporary variables at end of function: " + itos(used_temporaries.size()));
|
||||
}
|
||||
#endif
|
||||
append(GDScriptFunction::OPCODE_END, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_END);
|
||||
|
||||
for (int i = 0; i < temporaries.size(); i++) {
|
||||
int stack_index = i + max_locals + RESERVED_STACK;
|
||||
|
|
@ -424,115 +424,115 @@ void GDScriptByteCodeGenerator::set_initial_line(int p_line) {
|
|||
void GDScriptByteCodeGenerator::write_type_adjust(const Address &p_target, Variant::Type p_new_type) {
|
||||
switch (p_new_type) {
|
||||
case Variant::BOOL:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_BOOL, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_BOOL);
|
||||
break;
|
||||
case Variant::INT:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_INT, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_INT);
|
||||
break;
|
||||
case Variant::FLOAT:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_FLOAT, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_FLOAT);
|
||||
break;
|
||||
case Variant::STRING:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_STRING, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_STRING);
|
||||
break;
|
||||
case Variant::VECTOR2:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR2, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR2);
|
||||
break;
|
||||
case Variant::VECTOR2I:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR2I, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR2I);
|
||||
break;
|
||||
case Variant::RECT2:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_RECT2, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_RECT2);
|
||||
break;
|
||||
case Variant::RECT2I:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_RECT2I, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_RECT2I);
|
||||
break;
|
||||
case Variant::VECTOR3:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3);
|
||||
break;
|
||||
case Variant::VECTOR3I:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3I, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3I);
|
||||
break;
|
||||
case Variant::TRANSFORM2D:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_TRANSFORM2D, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_TRANSFORM2D);
|
||||
break;
|
||||
case Variant::VECTOR4:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3);
|
||||
break;
|
||||
case Variant::VECTOR4I:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3I, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3I);
|
||||
break;
|
||||
case Variant::PLANE:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_PLANE, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PLANE);
|
||||
break;
|
||||
case Variant::QUATERNION:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_QUATERNION, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_QUATERNION);
|
||||
break;
|
||||
case Variant::AABB:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_AABB, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_AABB);
|
||||
break;
|
||||
case Variant::BASIS:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_BASIS, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_BASIS);
|
||||
break;
|
||||
case Variant::TRANSFORM3D:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_TRANSFORM3D, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_TRANSFORM3D);
|
||||
break;
|
||||
case Variant::PROJECTION:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_PROJECTION, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PROJECTION);
|
||||
break;
|
||||
case Variant::COLOR:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_COLOR, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_COLOR);
|
||||
break;
|
||||
case Variant::STRING_NAME:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_STRING_NAME, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_STRING_NAME);
|
||||
break;
|
||||
case Variant::NODE_PATH:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_NODE_PATH, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_NODE_PATH);
|
||||
break;
|
||||
case Variant::RID:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_RID, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_RID);
|
||||
break;
|
||||
case Variant::OBJECT:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_OBJECT, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_OBJECT);
|
||||
break;
|
||||
case Variant::CALLABLE:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_CALLABLE, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_CALLABLE);
|
||||
break;
|
||||
case Variant::SIGNAL:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_SIGNAL, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_SIGNAL);
|
||||
break;
|
||||
case Variant::DICTIONARY:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_DICTIONARY, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_DICTIONARY);
|
||||
break;
|
||||
case Variant::ARRAY:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_ARRAY, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_ARRAY);
|
||||
break;
|
||||
case Variant::PACKED_BYTE_ARRAY:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_BYTE_ARRAY, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_BYTE_ARRAY);
|
||||
break;
|
||||
case Variant::PACKED_INT32_ARRAY:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_INT32_ARRAY, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_INT32_ARRAY);
|
||||
break;
|
||||
case Variant::PACKED_INT64_ARRAY:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_INT64_ARRAY, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_INT64_ARRAY);
|
||||
break;
|
||||
case Variant::PACKED_FLOAT32_ARRAY:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_FLOAT32_ARRAY, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_FLOAT32_ARRAY);
|
||||
break;
|
||||
case Variant::PACKED_FLOAT64_ARRAY:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_FLOAT64_ARRAY, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_FLOAT64_ARRAY);
|
||||
break;
|
||||
case Variant::PACKED_STRING_ARRAY:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_STRING_ARRAY, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_STRING_ARRAY);
|
||||
break;
|
||||
case Variant::PACKED_VECTOR2_ARRAY:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_VECTOR2_ARRAY, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_VECTOR2_ARRAY);
|
||||
break;
|
||||
case Variant::PACKED_VECTOR3_ARRAY:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_VECTOR3_ARRAY, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_VECTOR3_ARRAY);
|
||||
break;
|
||||
case Variant::PACKED_COLOR_ARRAY:
|
||||
append(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_COLOR_ARRAY, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_COLOR_ARRAY);
|
||||
break;
|
||||
case Variant::NIL:
|
||||
case Variant::VARIANT_MAX:
|
||||
|
|
@ -546,7 +546,7 @@ void GDScriptByteCodeGenerator::write_unary_operator(const Address &p_target, Va
|
|||
// Gather specific operator.
|
||||
Variant::ValidatedOperatorEvaluator op_func = Variant::get_validated_operator_evaluator(p_operator, p_left_operand.type.builtin_type, Variant::NIL);
|
||||
|
||||
append(GDScriptFunction::OPCODE_OPERATOR_VALIDATED, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_OPERATOR_VALIDATED);
|
||||
append(p_left_operand);
|
||||
append(Address());
|
||||
append(p_target);
|
||||
|
|
@ -555,7 +555,7 @@ void GDScriptByteCodeGenerator::write_unary_operator(const Address &p_target, Va
|
|||
}
|
||||
|
||||
// No specific types, perform variant evaluation.
|
||||
append(GDScriptFunction::OPCODE_OPERATOR, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_OPERATOR);
|
||||
append(p_left_operand);
|
||||
append(Address());
|
||||
append(p_target);
|
||||
|
|
@ -575,7 +575,7 @@ void GDScriptByteCodeGenerator::write_binary_operator(const Address &p_target, V
|
|||
// Gather specific operator.
|
||||
Variant::ValidatedOperatorEvaluator op_func = Variant::get_validated_operator_evaluator(p_operator, p_left_operand.type.builtin_type, p_right_operand.type.builtin_type);
|
||||
|
||||
append(GDScriptFunction::OPCODE_OPERATOR_VALIDATED, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_OPERATOR_VALIDATED);
|
||||
append(p_left_operand);
|
||||
append(p_right_operand);
|
||||
append(p_target);
|
||||
|
|
@ -584,7 +584,7 @@ void GDScriptByteCodeGenerator::write_binary_operator(const Address &p_target, V
|
|||
}
|
||||
|
||||
// No specific types, perform variant evaluation.
|
||||
append(GDScriptFunction::OPCODE_OPERATOR, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_OPERATOR);
|
||||
append(p_left_operand);
|
||||
append(p_right_operand);
|
||||
append(p_target);
|
||||
|
|
@ -592,28 +592,28 @@ void GDScriptByteCodeGenerator::write_binary_operator(const Address &p_target, V
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_type_test(const Address &p_target, const Address &p_source, const Address &p_type) {
|
||||
append(GDScriptFunction::OPCODE_EXTENDS_TEST, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_EXTENDS_TEST);
|
||||
append(p_source);
|
||||
append(p_type);
|
||||
append(p_target);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_type_test_builtin(const Address &p_target, const Address &p_source, Variant::Type p_type) {
|
||||
append(GDScriptFunction::OPCODE_IS_BUILTIN, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_IS_BUILTIN);
|
||||
append(p_source);
|
||||
append(p_target);
|
||||
append(p_type);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_and_left_operand(const Address &p_left_operand) {
|
||||
append(GDScriptFunction::OPCODE_JUMP_IF_NOT, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_NOT);
|
||||
append(p_left_operand);
|
||||
logic_op_jump_pos1.push_back(opcodes.size());
|
||||
append(0); // Jump target, will be patched.
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_and_right_operand(const Address &p_right_operand) {
|
||||
append(GDScriptFunction::OPCODE_JUMP_IF_NOT, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_NOT);
|
||||
append(p_right_operand);
|
||||
logic_op_jump_pos2.push_back(opcodes.size());
|
||||
append(0); // Jump target, will be patched.
|
||||
|
|
@ -621,29 +621,29 @@ void GDScriptByteCodeGenerator::write_and_right_operand(const Address &p_right_o
|
|||
|
||||
void GDScriptByteCodeGenerator::write_end_and(const Address &p_target) {
|
||||
// If here means both operands are true.
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_TRUE, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TRUE);
|
||||
append(p_target);
|
||||
// Jump away from the fail condition.
|
||||
append(GDScriptFunction::OPCODE_JUMP, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP);
|
||||
append(opcodes.size() + 3);
|
||||
// Here it means one of operands is false.
|
||||
patch_jump(logic_op_jump_pos1.back()->get());
|
||||
patch_jump(logic_op_jump_pos2.back()->get());
|
||||
logic_op_jump_pos1.pop_back();
|
||||
logic_op_jump_pos2.pop_back();
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_FALSE, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_FALSE);
|
||||
append(p_target);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_or_left_operand(const Address &p_left_operand) {
|
||||
append(GDScriptFunction::OPCODE_JUMP_IF, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP_IF);
|
||||
append(p_left_operand);
|
||||
logic_op_jump_pos1.push_back(opcodes.size());
|
||||
append(0); // Jump target, will be patched.
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_or_right_operand(const Address &p_right_operand) {
|
||||
append(GDScriptFunction::OPCODE_JUMP_IF, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP_IF);
|
||||
append(p_right_operand);
|
||||
logic_op_jump_pos2.push_back(opcodes.size());
|
||||
append(0); // Jump target, will be patched.
|
||||
|
|
@ -651,17 +651,17 @@ void GDScriptByteCodeGenerator::write_or_right_operand(const Address &p_right_op
|
|||
|
||||
void GDScriptByteCodeGenerator::write_end_or(const Address &p_target) {
|
||||
// If here means both operands are false.
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_FALSE, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_FALSE);
|
||||
append(p_target);
|
||||
// Jump away from the success condition.
|
||||
append(GDScriptFunction::OPCODE_JUMP, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP);
|
||||
append(opcodes.size() + 3);
|
||||
// Here it means one of operands is true.
|
||||
patch_jump(logic_op_jump_pos1.back()->get());
|
||||
patch_jump(logic_op_jump_pos2.back()->get());
|
||||
logic_op_jump_pos1.pop_back();
|
||||
logic_op_jump_pos2.pop_back();
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_TRUE, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TRUE);
|
||||
append(p_target);
|
||||
}
|
||||
|
||||
|
|
@ -670,18 +670,18 @@ void GDScriptByteCodeGenerator::write_start_ternary(const Address &p_target) {
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_ternary_condition(const Address &p_condition) {
|
||||
append(GDScriptFunction::OPCODE_JUMP_IF_NOT, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_NOT);
|
||||
append(p_condition);
|
||||
ternary_jump_fail_pos.push_back(opcodes.size());
|
||||
append(0); // Jump target, will be patched.
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_ternary_true_expr(const Address &p_expr) {
|
||||
append(GDScriptFunction::OPCODE_ASSIGN, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN);
|
||||
append(ternary_result.back()->get());
|
||||
append(p_expr);
|
||||
// Jump away from the false path.
|
||||
append(GDScriptFunction::OPCODE_JUMP, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP);
|
||||
ternary_jump_skip_pos.push_back(opcodes.size());
|
||||
append(0);
|
||||
// Fail must jump here.
|
||||
|
|
@ -690,7 +690,7 @@ void GDScriptByteCodeGenerator::write_ternary_true_expr(const Address &p_expr) {
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_ternary_false_expr(const Address &p_expr) {
|
||||
append(GDScriptFunction::OPCODE_ASSIGN, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN);
|
||||
append(ternary_result.back()->get());
|
||||
append(p_expr);
|
||||
}
|
||||
|
|
@ -707,7 +707,7 @@ void GDScriptByteCodeGenerator::write_set(const Address &p_target, const Address
|
|||
IS_BUILTIN_TYPE(p_source, Variant::get_indexed_element_type(p_target.type.builtin_type))) {
|
||||
// Use indexed setter instead.
|
||||
Variant::ValidatedIndexedSetter setter = Variant::get_member_validated_indexed_setter(p_target.type.builtin_type);
|
||||
append(GDScriptFunction::OPCODE_SET_INDEXED_VALIDATED, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_SET_INDEXED_VALIDATED);
|
||||
append(p_target);
|
||||
append(p_index);
|
||||
append(p_source);
|
||||
|
|
@ -715,7 +715,7 @@ void GDScriptByteCodeGenerator::write_set(const Address &p_target, const Address
|
|||
return;
|
||||
} else if (Variant::get_member_validated_keyed_setter(p_target.type.builtin_type)) {
|
||||
Variant::ValidatedKeyedSetter setter = Variant::get_member_validated_keyed_setter(p_target.type.builtin_type);
|
||||
append(GDScriptFunction::OPCODE_SET_KEYED_VALIDATED, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_SET_KEYED_VALIDATED);
|
||||
append(p_target);
|
||||
append(p_index);
|
||||
append(p_source);
|
||||
|
|
@ -724,7 +724,7 @@ void GDScriptByteCodeGenerator::write_set(const Address &p_target, const Address
|
|||
}
|
||||
}
|
||||
|
||||
append(GDScriptFunction::OPCODE_SET_KEYED, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_SET_KEYED);
|
||||
append(p_target);
|
||||
append(p_index);
|
||||
append(p_source);
|
||||
|
|
@ -735,7 +735,7 @@ void GDScriptByteCodeGenerator::write_get(const Address &p_target, const Address
|
|||
if (IS_BUILTIN_TYPE(p_index, Variant::INT) && Variant::get_member_validated_indexed_getter(p_source.type.builtin_type)) {
|
||||
// Use indexed getter instead.
|
||||
Variant::ValidatedIndexedGetter getter = Variant::get_member_validated_indexed_getter(p_source.type.builtin_type);
|
||||
append(GDScriptFunction::OPCODE_GET_INDEXED_VALIDATED, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_GET_INDEXED_VALIDATED);
|
||||
append(p_source);
|
||||
append(p_index);
|
||||
append(p_target);
|
||||
|
|
@ -743,7 +743,7 @@ void GDScriptByteCodeGenerator::write_get(const Address &p_target, const Address
|
|||
return;
|
||||
} else if (Variant::get_member_validated_keyed_getter(p_source.type.builtin_type)) {
|
||||
Variant::ValidatedKeyedGetter getter = Variant::get_member_validated_keyed_getter(p_source.type.builtin_type);
|
||||
append(GDScriptFunction::OPCODE_GET_KEYED_VALIDATED, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_GET_KEYED_VALIDATED);
|
||||
append(p_source);
|
||||
append(p_index);
|
||||
append(p_target);
|
||||
|
|
@ -751,7 +751,7 @@ void GDScriptByteCodeGenerator::write_get(const Address &p_target, const Address
|
|||
return;
|
||||
}
|
||||
}
|
||||
append(GDScriptFunction::OPCODE_GET_KEYED, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_GET_KEYED);
|
||||
append(p_source);
|
||||
append(p_index);
|
||||
append(p_target);
|
||||
|
|
@ -761,13 +761,13 @@ void GDScriptByteCodeGenerator::write_set_named(const Address &p_target, const S
|
|||
if (HAS_BUILTIN_TYPE(p_target) && Variant::get_member_validated_setter(p_target.type.builtin_type, p_name) &&
|
||||
IS_BUILTIN_TYPE(p_source, Variant::get_member_type(p_target.type.builtin_type, p_name))) {
|
||||
Variant::ValidatedSetter setter = Variant::get_member_validated_setter(p_target.type.builtin_type, p_name);
|
||||
append(GDScriptFunction::OPCODE_SET_NAMED_VALIDATED, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_SET_NAMED_VALIDATED);
|
||||
append(p_target);
|
||||
append(p_source);
|
||||
append(setter);
|
||||
return;
|
||||
}
|
||||
append(GDScriptFunction::OPCODE_SET_NAMED, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_SET_NAMED);
|
||||
append(p_target);
|
||||
append(p_source);
|
||||
append(p_name);
|
||||
|
|
@ -776,26 +776,26 @@ void GDScriptByteCodeGenerator::write_set_named(const Address &p_target, const S
|
|||
void GDScriptByteCodeGenerator::write_get_named(const Address &p_target, const StringName &p_name, const Address &p_source) {
|
||||
if (HAS_BUILTIN_TYPE(p_source) && Variant::get_member_validated_getter(p_source.type.builtin_type, p_name)) {
|
||||
Variant::ValidatedGetter getter = Variant::get_member_validated_getter(p_source.type.builtin_type, p_name);
|
||||
append(GDScriptFunction::OPCODE_GET_NAMED_VALIDATED, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_GET_NAMED_VALIDATED);
|
||||
append(p_source);
|
||||
append(p_target);
|
||||
append(getter);
|
||||
return;
|
||||
}
|
||||
append(GDScriptFunction::OPCODE_GET_NAMED, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_GET_NAMED);
|
||||
append(p_source);
|
||||
append(p_target);
|
||||
append(p_name);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_set_member(const Address &p_value, const StringName &p_name) {
|
||||
append(GDScriptFunction::OPCODE_SET_MEMBER, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_SET_MEMBER);
|
||||
append(p_value);
|
||||
append(p_name);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_get_member(const Address &p_target, const StringName &p_name) {
|
||||
append(GDScriptFunction::OPCODE_GET_MEMBER, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_GET_MEMBER);
|
||||
append(p_target);
|
||||
append(p_name);
|
||||
}
|
||||
|
|
@ -804,11 +804,11 @@ void GDScriptByteCodeGenerator::write_assign_with_conversion(const Address &p_ta
|
|||
switch (p_target.type.kind) {
|
||||
case GDScriptDataType::BUILTIN: {
|
||||
if (p_target.type.builtin_type == Variant::ARRAY && p_target.type.has_container_element_type()) {
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_TYPED_ARRAY, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_ARRAY);
|
||||
append(p_target);
|
||||
append(p_source);
|
||||
} else {
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_TYPED_BUILTIN, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_BUILTIN);
|
||||
append(p_target);
|
||||
append(p_source);
|
||||
append(p_target.type.builtin_type);
|
||||
|
|
@ -818,7 +818,7 @@ void GDScriptByteCodeGenerator::write_assign_with_conversion(const Address &p_ta
|
|||
int class_idx = GDScriptLanguage::get_singleton()->get_global_map()[p_target.type.native_type];
|
||||
Variant nc = GDScriptLanguage::get_singleton()->get_global_array()[class_idx];
|
||||
class_idx = get_constant_pos(nc) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_TYPED_NATIVE, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_NATIVE);
|
||||
append(p_target);
|
||||
append(p_source);
|
||||
append(class_idx);
|
||||
|
|
@ -828,7 +828,7 @@ void GDScriptByteCodeGenerator::write_assign_with_conversion(const Address &p_ta
|
|||
Variant script = p_target.type.script_type;
|
||||
int idx = get_constant_pos(script) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
|
||||
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_TYPED_SCRIPT, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_SCRIPT);
|
||||
append(p_target);
|
||||
append(p_source);
|
||||
append(idx);
|
||||
|
|
@ -837,7 +837,7 @@ void GDScriptByteCodeGenerator::write_assign_with_conversion(const Address &p_ta
|
|||
ERR_PRINT("Compiler bug: unresolved assign.");
|
||||
|
||||
// Shouldn't get here, but fail-safe to a regular assignment
|
||||
append(GDScriptFunction::OPCODE_ASSIGN, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN);
|
||||
append(p_target);
|
||||
append(p_source);
|
||||
}
|
||||
|
|
@ -846,29 +846,29 @@ void GDScriptByteCodeGenerator::write_assign_with_conversion(const Address &p_ta
|
|||
|
||||
void GDScriptByteCodeGenerator::write_assign(const Address &p_target, const Address &p_source) {
|
||||
if (p_target.type.kind == GDScriptDataType::BUILTIN && p_target.type.builtin_type == Variant::ARRAY && p_target.type.has_container_element_type()) {
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_TYPED_ARRAY, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_ARRAY);
|
||||
append(p_target);
|
||||
append(p_source);
|
||||
} else if (p_target.type.kind == GDScriptDataType::BUILTIN && p_source.type.kind == GDScriptDataType::BUILTIN && p_target.type.builtin_type != p_source.type.builtin_type) {
|
||||
// Need conversion.
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_TYPED_BUILTIN, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_BUILTIN);
|
||||
append(p_target);
|
||||
append(p_source);
|
||||
append(p_target.type.builtin_type);
|
||||
} else {
|
||||
append(GDScriptFunction::OPCODE_ASSIGN, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN);
|
||||
append(p_target);
|
||||
append(p_source);
|
||||
}
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_assign_true(const Address &p_target) {
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_TRUE, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TRUE);
|
||||
append(p_target);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_assign_false(const Address &p_target) {
|
||||
append(GDScriptFunction::OPCODE_ASSIGN_FALSE, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN_FALSE);
|
||||
append(p_target);
|
||||
}
|
||||
|
||||
|
|
@ -878,13 +878,13 @@ void GDScriptByteCodeGenerator::write_assign_default_parameter(const Address &p_
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_store_global(const Address &p_dst, int p_global_index) {
|
||||
append(GDScriptFunction::OPCODE_STORE_GLOBAL, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_STORE_GLOBAL);
|
||||
append(p_dst);
|
||||
append(p_global_index);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_store_named_global(const Address &p_dst, const StringName &p_global) {
|
||||
append(GDScriptFunction::OPCODE_STORE_NAMED_GLOBAL, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_STORE_NAMED_GLOBAL);
|
||||
append(p_dst);
|
||||
append(p_global);
|
||||
}
|
||||
|
|
@ -894,20 +894,20 @@ void GDScriptByteCodeGenerator::write_cast(const Address &p_target, const Addres
|
|||
|
||||
switch (p_type.kind) {
|
||||
case GDScriptDataType::BUILTIN: {
|
||||
append(GDScriptFunction::OPCODE_CAST_TO_BUILTIN, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_CAST_TO_BUILTIN);
|
||||
index = p_type.builtin_type;
|
||||
} break;
|
||||
case GDScriptDataType::NATIVE: {
|
||||
int class_idx = GDScriptLanguage::get_singleton()->get_global_map()[p_type.native_type];
|
||||
Variant nc = GDScriptLanguage::get_singleton()->get_global_array()[class_idx];
|
||||
append(GDScriptFunction::OPCODE_CAST_TO_NATIVE, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_CAST_TO_NATIVE);
|
||||
index = get_constant_pos(nc) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
|
||||
} break;
|
||||
case GDScriptDataType::SCRIPT:
|
||||
case GDScriptDataType::GDSCRIPT: {
|
||||
Variant script = p_type.script_type;
|
||||
int idx = get_constant_pos(script) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
|
||||
append(GDScriptFunction::OPCODE_CAST_TO_SCRIPT, 3);
|
||||
append_opcode(GDScriptFunction::OPCODE_CAST_TO_SCRIPT);
|
||||
index = idx;
|
||||
} break;
|
||||
default: {
|
||||
|
|
@ -921,7 +921,7 @@ void GDScriptByteCodeGenerator::write_cast(const Address &p_target, const Addres
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_call(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) {
|
||||
append(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN, 2 + p_arguments.size());
|
||||
append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN, 2 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -932,7 +932,7 @@ void GDScriptByteCodeGenerator::write_call(const Address &p_target, const Addres
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_super_call(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) {
|
||||
append(GDScriptFunction::OPCODE_CALL_SELF_BASE, 1 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_SELF_BASE, 1 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -942,7 +942,7 @@ void GDScriptByteCodeGenerator::write_super_call(const Address &p_target, const
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_call_async(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) {
|
||||
append(GDScriptFunction::OPCODE_CALL_ASYNC, 2 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_ASYNC, 2 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -953,7 +953,7 @@ void GDScriptByteCodeGenerator::write_call_async(const Address &p_target, const
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_call_gdscript_utility(const Address &p_target, GDScriptUtilityFunctions::FunctionPtr p_function, const Vector<Address> &p_arguments) {
|
||||
append(GDScriptFunction::OPCODE_CALL_GDSCRIPT_UTILITY, 1 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_GDSCRIPT_UTILITY, 1 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -979,7 +979,7 @@ void GDScriptByteCodeGenerator::write_call_utility(const Address &p_target, cons
|
|||
}
|
||||
|
||||
if (is_validated) {
|
||||
append(GDScriptFunction::OPCODE_CALL_UTILITY_VALIDATED, 1 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_UTILITY_VALIDATED, 1 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -987,7 +987,7 @@ void GDScriptByteCodeGenerator::write_call_utility(const Address &p_target, cons
|
|||
append(p_arguments.size());
|
||||
append(Variant::get_validated_utility_function(p_function));
|
||||
} else {
|
||||
append(GDScriptFunction::OPCODE_CALL_UTILITY, 1 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_UTILITY, 1 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1029,7 +1029,7 @@ void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target,
|
|||
}
|
||||
}
|
||||
|
||||
append(GDScriptFunction::OPCODE_CALL_BUILTIN_TYPE_VALIDATED, 2 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_BUILTIN_TYPE_VALIDATED, 2 + p_arguments.size());
|
||||
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
|
|
@ -1060,7 +1060,7 @@ void GDScriptByteCodeGenerator::write_call_builtin_type_static(const Address &p_
|
|||
|
||||
if (!is_validated) {
|
||||
// Perform regular call.
|
||||
append(GDScriptFunction::OPCODE_CALL_BUILTIN_STATIC, p_arguments.size() + 1);
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_BUILTIN_STATIC, p_arguments.size() + 1);
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1079,7 +1079,7 @@ void GDScriptByteCodeGenerator::write_call_builtin_type_static(const Address &p_
|
|||
}
|
||||
}
|
||||
|
||||
append(GDScriptFunction::OPCODE_CALL_BUILTIN_TYPE_VALIDATED, 2 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_BUILTIN_TYPE_VALIDATED, 2 + p_arguments.size());
|
||||
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
|
|
@ -1097,7 +1097,7 @@ void GDScriptByteCodeGenerator::write_call_native_static(const Address &p_target
|
|||
|
||||
if (!is_validated) {
|
||||
// Perform regular call.
|
||||
append(GDScriptFunction::OPCODE_CALL_NATIVE_STATIC, p_arguments.size() + 1);
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_NATIVE_STATIC, p_arguments.size() + 1);
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1109,7 +1109,7 @@ void GDScriptByteCodeGenerator::write_call_native_static(const Address &p_target
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_call_method_bind(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) {
|
||||
append(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL_METHOD_BIND : GDScriptFunction::OPCODE_CALL_METHOD_BIND_RET, 2 + p_arguments.size());
|
||||
append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL_METHOD_BIND : GDScriptFunction::OPCODE_CALL_METHOD_BIND_RET, 2 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1120,9 +1120,9 @@ void GDScriptByteCodeGenerator::write_call_method_bind(const Address &p_target,
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_call_ptrcall(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) {
|
||||
#define CASE_TYPE(m_type) \
|
||||
case Variant::m_type: \
|
||||
append(GDScriptFunction::OPCODE_CALL_PTRCALL_##m_type, 2 + p_arguments.size()); \
|
||||
#define CASE_TYPE(m_type) \
|
||||
case Variant::m_type: \
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_PTRCALL_##m_type, 2 + p_arguments.size()); \
|
||||
break
|
||||
|
||||
bool is_ptrcall = true;
|
||||
|
|
@ -1166,12 +1166,12 @@ void GDScriptByteCodeGenerator::write_call_ptrcall(const Address &p_target, cons
|
|||
CASE_TYPE(PACKED_VECTOR3_ARRAY);
|
||||
CASE_TYPE(PACKED_COLOR_ARRAY);
|
||||
default:
|
||||
append(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL_METHOD_BIND : GDScriptFunction::OPCODE_CALL_METHOD_BIND_RET, 2 + p_arguments.size());
|
||||
append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL_METHOD_BIND : GDScriptFunction::OPCODE_CALL_METHOD_BIND_RET, 2 + p_arguments.size());
|
||||
is_ptrcall = false;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
append(GDScriptFunction::OPCODE_CALL_PTRCALL_NO_RETURN, 2 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_PTRCALL_NO_RETURN, 2 + p_arguments.size());
|
||||
}
|
||||
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
|
|
@ -1189,7 +1189,7 @@ void GDScriptByteCodeGenerator::write_call_ptrcall(const Address &p_target, cons
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_call_self(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) {
|
||||
append(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN, 2 + p_arguments.size());
|
||||
append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN, 2 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1200,7 +1200,7 @@ void GDScriptByteCodeGenerator::write_call_self(const Address &p_target, const S
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_call_self_async(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) {
|
||||
append(GDScriptFunction::OPCODE_CALL_ASYNC, 2 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_ASYNC, 2 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1211,7 +1211,7 @@ void GDScriptByteCodeGenerator::write_call_self_async(const Address &p_target, c
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_call_script_function(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) {
|
||||
append(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN, 2 + p_arguments.size());
|
||||
append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN, 2 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1222,7 +1222,7 @@ void GDScriptByteCodeGenerator::write_call_script_function(const Address &p_targ
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_lambda(const Address &p_target, GDScriptFunction *p_function, const Vector<Address> &p_captures, bool p_use_self) {
|
||||
append(p_use_self ? GDScriptFunction::OPCODE_CREATE_SELF_LAMBDA : GDScriptFunction::OPCODE_CREATE_LAMBDA, 1 + p_captures.size());
|
||||
append_opcode_and_argcount(p_use_self ? GDScriptFunction::OPCODE_CREATE_SELF_LAMBDA : GDScriptFunction::OPCODE_CREATE_LAMBDA, 1 + p_captures.size());
|
||||
for (int i = 0; i < p_captures.size(); i++) {
|
||||
append(p_captures[i]);
|
||||
}
|
||||
|
|
@ -1262,7 +1262,7 @@ void GDScriptByteCodeGenerator::write_construct(const Address &p_target, Variant
|
|||
}
|
||||
}
|
||||
if (valid_constructor >= 0) {
|
||||
append(GDScriptFunction::OPCODE_CONSTRUCT_VALIDATED, 1 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT_VALIDATED, 1 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1273,7 +1273,7 @@ void GDScriptByteCodeGenerator::write_construct(const Address &p_target, Variant
|
|||
}
|
||||
}
|
||||
|
||||
append(GDScriptFunction::OPCODE_CONSTRUCT, 1 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT, 1 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1283,7 +1283,7 @@ void GDScriptByteCodeGenerator::write_construct(const Address &p_target, Variant
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_construct_array(const Address &p_target, const Vector<Address> &p_arguments) {
|
||||
append(GDScriptFunction::OPCODE_CONSTRUCT_ARRAY, 1 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT_ARRAY, 1 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1292,7 +1292,7 @@ void GDScriptByteCodeGenerator::write_construct_array(const Address &p_target, c
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_construct_typed_array(const Address &p_target, const GDScriptDataType &p_element_type, const Vector<Address> &p_arguments) {
|
||||
append(GDScriptFunction::OPCODE_CONSTRUCT_TYPED_ARRAY, 2 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT_TYPED_ARRAY, 2 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1311,7 +1311,7 @@ void GDScriptByteCodeGenerator::write_construct_typed_array(const Address &p_tar
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_construct_dictionary(const Address &p_target, const Vector<Address> &p_arguments) {
|
||||
append(GDScriptFunction::OPCODE_CONSTRUCT_DICTIONARY, 1 + p_arguments.size());
|
||||
append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT_DICTIONARY, 1 + p_arguments.size());
|
||||
for (int i = 0; i < p_arguments.size(); i++) {
|
||||
append(p_arguments[i]);
|
||||
}
|
||||
|
|
@ -1320,21 +1320,21 @@ void GDScriptByteCodeGenerator::write_construct_dictionary(const Address &p_targ
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_await(const Address &p_target, const Address &p_operand) {
|
||||
append(GDScriptFunction::OPCODE_AWAIT, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_AWAIT);
|
||||
append(p_operand);
|
||||
append(GDScriptFunction::OPCODE_AWAIT_RESUME, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_AWAIT_RESUME);
|
||||
append(p_target);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_if(const Address &p_condition) {
|
||||
append(GDScriptFunction::OPCODE_JUMP_IF_NOT, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_NOT);
|
||||
append(p_condition);
|
||||
if_jmp_addrs.push_back(opcodes.size());
|
||||
append(0); // Jump destination, will be patched.
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_else() {
|
||||
append(GDScriptFunction::OPCODE_JUMP, 0); // Jump from true if block;
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP); // Jump from true if block;
|
||||
int else_jmp_addr = opcodes.size();
|
||||
append(0); // Jump destination, will be patched.
|
||||
|
||||
|
|
@ -1349,7 +1349,7 @@ void GDScriptByteCodeGenerator::write_endif() {
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_jump_if_shared(const Address &p_value) {
|
||||
append(GDScriptFunction::OPCODE_JUMP_IF_SHARED, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_SHARED);
|
||||
append(p_value);
|
||||
if_jmp_addrs.push_back(opcodes.size());
|
||||
append(0); // Jump destination, will be patched.
|
||||
|
|
@ -1373,7 +1373,7 @@ void GDScriptByteCodeGenerator::write_for_assignment(const Address &p_variable,
|
|||
const Address &container = for_container_variables.back()->get();
|
||||
|
||||
// Assign container.
|
||||
append(GDScriptFunction::OPCODE_ASSIGN, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSIGN);
|
||||
append(container);
|
||||
append(p_list);
|
||||
|
||||
|
|
@ -1475,19 +1475,19 @@ void GDScriptByteCodeGenerator::write_for() {
|
|||
}
|
||||
|
||||
// Begin loop.
|
||||
append(begin_opcode, 3);
|
||||
append_opcode(begin_opcode);
|
||||
append(counter);
|
||||
append(container);
|
||||
append(iterator);
|
||||
for_jmp_addrs.push_back(opcodes.size());
|
||||
append(0); // End of loop address, will be patched.
|
||||
append(GDScriptFunction::OPCODE_JUMP, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP);
|
||||
append(opcodes.size() + 6); // Skip over 'continue' code.
|
||||
|
||||
// Next iteration.
|
||||
int continue_addr = opcodes.size();
|
||||
continue_addrs.push_back(continue_addr);
|
||||
append(iterate_opcode, 3);
|
||||
append_opcode(iterate_opcode);
|
||||
append(counter);
|
||||
append(container);
|
||||
append(iterator);
|
||||
|
|
@ -1497,7 +1497,7 @@ void GDScriptByteCodeGenerator::write_for() {
|
|||
|
||||
void GDScriptByteCodeGenerator::write_endfor() {
|
||||
// Jump back to loop check.
|
||||
append(GDScriptFunction::OPCODE_JUMP, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP);
|
||||
append(continue_addrs.back()->get());
|
||||
continue_addrs.pop_back();
|
||||
|
||||
|
|
@ -1526,7 +1526,7 @@ void GDScriptByteCodeGenerator::start_while_condition() {
|
|||
|
||||
void GDScriptByteCodeGenerator::write_while(const Address &p_condition) {
|
||||
// Condition check.
|
||||
append(GDScriptFunction::OPCODE_JUMP_IF_NOT, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_NOT);
|
||||
append(p_condition);
|
||||
while_jmp_addrs.push_back(opcodes.size());
|
||||
append(0); // End of loop address, will be patched.
|
||||
|
|
@ -1534,7 +1534,7 @@ void GDScriptByteCodeGenerator::write_while(const Address &p_condition) {
|
|||
|
||||
void GDScriptByteCodeGenerator::write_endwhile() {
|
||||
// Jump back to loop check.
|
||||
append(GDScriptFunction::OPCODE_JUMP, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP);
|
||||
append(continue_addrs.back()->get());
|
||||
continue_addrs.pop_back();
|
||||
|
||||
|
|
@ -1572,28 +1572,28 @@ void GDScriptByteCodeGenerator::end_match() {
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_break() {
|
||||
append(GDScriptFunction::OPCODE_JUMP, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP);
|
||||
current_breaks_to_patch.back()->get().push_back(opcodes.size());
|
||||
append(0);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_continue() {
|
||||
append(GDScriptFunction::OPCODE_JUMP, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP);
|
||||
append(continue_addrs.back()->get());
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_continue_match() {
|
||||
append(GDScriptFunction::OPCODE_JUMP, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_JUMP);
|
||||
match_continues_to_patch.back()->get().push_back(opcodes.size());
|
||||
append(0);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_breakpoint() {
|
||||
append(GDScriptFunction::OPCODE_BREAKPOINT, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_BREAKPOINT);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_newline(int p_line) {
|
||||
append(GDScriptFunction::OPCODE_LINE, 0);
|
||||
append_opcode(GDScriptFunction::OPCODE_LINE);
|
||||
append(p_line);
|
||||
current_line = p_line;
|
||||
}
|
||||
|
|
@ -1611,23 +1611,23 @@ void GDScriptByteCodeGenerator::write_return(const Address &p_return_value) {
|
|||
Variant script = element_type.script_type;
|
||||
int script_idx = get_constant_pos(script) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
|
||||
|
||||
append(GDScriptFunction::OPCODE_RETURN_TYPED_ARRAY, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_ARRAY);
|
||||
append(p_return_value);
|
||||
append(script_idx);
|
||||
append(element_type.kind == GDScriptDataType::BUILTIN ? element_type.builtin_type : Variant::OBJECT);
|
||||
append(element_type.native_type);
|
||||
} else if (function->return_type.kind == GDScriptDataType::BUILTIN && p_return_value.type.kind == GDScriptDataType::BUILTIN && function->return_type.builtin_type != p_return_value.type.builtin_type) {
|
||||
// Add conversion.
|
||||
append(GDScriptFunction::OPCODE_RETURN_TYPED_BUILTIN, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_BUILTIN);
|
||||
append(p_return_value);
|
||||
append(function->return_type.builtin_type);
|
||||
} else {
|
||||
// Just assign.
|
||||
append(GDScriptFunction::OPCODE_RETURN, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_RETURN);
|
||||
append(p_return_value);
|
||||
}
|
||||
} else {
|
||||
append(GDScriptFunction::OPCODE_RETURN, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_RETURN);
|
||||
append(p_return_value);
|
||||
}
|
||||
} else {
|
||||
|
|
@ -1640,19 +1640,19 @@ void GDScriptByteCodeGenerator::write_return(const Address &p_return_value) {
|
|||
int script_idx = get_constant_pos(script);
|
||||
script_idx |= (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
|
||||
|
||||
append(GDScriptFunction::OPCODE_RETURN_TYPED_ARRAY, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_ARRAY);
|
||||
append(p_return_value);
|
||||
append(script_idx);
|
||||
append(element_type.kind == GDScriptDataType::BUILTIN ? element_type.builtin_type : Variant::OBJECT);
|
||||
append(element_type.native_type);
|
||||
} else {
|
||||
append(GDScriptFunction::OPCODE_RETURN_TYPED_BUILTIN, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_BUILTIN);
|
||||
append(p_return_value);
|
||||
append(function->return_type.builtin_type);
|
||||
}
|
||||
} break;
|
||||
case GDScriptDataType::NATIVE: {
|
||||
append(GDScriptFunction::OPCODE_RETURN_TYPED_NATIVE, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_NATIVE);
|
||||
append(p_return_value);
|
||||
int class_idx = GDScriptLanguage::get_singleton()->get_global_map()[function->return_type.native_type];
|
||||
Variant nc = GDScriptLanguage::get_singleton()->get_global_array()[class_idx];
|
||||
|
|
@ -1664,7 +1664,7 @@ void GDScriptByteCodeGenerator::write_return(const Address &p_return_value) {
|
|||
Variant script = function->return_type.script_type;
|
||||
int script_idx = get_constant_pos(script) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
|
||||
|
||||
append(GDScriptFunction::OPCODE_RETURN_TYPED_SCRIPT, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_SCRIPT);
|
||||
append(p_return_value);
|
||||
append(script_idx);
|
||||
} break;
|
||||
|
|
@ -1672,7 +1672,7 @@ void GDScriptByteCodeGenerator::write_return(const Address &p_return_value) {
|
|||
ERR_PRINT("Compiler bug: unresolved return.");
|
||||
|
||||
// Shouldn't get here, but fail-safe to a regular return;
|
||||
append(GDScriptFunction::OPCODE_RETURN, 1);
|
||||
append_opcode(GDScriptFunction::OPCODE_RETURN);
|
||||
append(p_return_value);
|
||||
} break;
|
||||
}
|
||||
|
|
@ -1680,7 +1680,7 @@ void GDScriptByteCodeGenerator::write_return(const Address &p_return_value) {
|
|||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_assert(const Address &p_test, const Address &p_message) {
|
||||
append(GDScriptFunction::OPCODE_ASSERT, 2);
|
||||
append_opcode(GDScriptFunction::OPCODE_ASSERT);
|
||||
append(p_test);
|
||||
append(p_message);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -331,8 +331,13 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
|
|||
return -1; // Unreachable.
|
||||
}
|
||||
|
||||
void append(GDScriptFunction::Opcode p_code, int p_argument_count) {
|
||||
opcodes.push_back((p_code & GDScriptFunction::INSTR_MASK) | (p_argument_count << GDScriptFunction::INSTR_BITS));
|
||||
void append_opcode(GDScriptFunction::Opcode p_code) {
|
||||
opcodes.push_back(p_code);
|
||||
}
|
||||
|
||||
void append_opcode_and_argcount(GDScriptFunction::Opcode p_code, int p_argument_count) {
|
||||
opcodes.push_back(p_code);
|
||||
opcodes.push_back(p_argument_count);
|
||||
instr_args_max = MAX(instr_args_max, p_argument_count);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -104,8 +104,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
text += ": ";
|
||||
|
||||
// This makes the compiler complain if some opcode is unchecked in the switch.
|
||||
Opcode opcode = Opcode(_code_ptr[ip] & INSTR_MASK);
|
||||
int instr_var_args = (_code_ptr[ip] & INSTR_ARGS_MASK) >> INSTR_BITS;
|
||||
Opcode opcode = Opcode(_code_ptr[ip]);
|
||||
|
||||
switch (opcode) {
|
||||
case OPCODE_OPERATOR: {
|
||||
|
|
@ -372,6 +371,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr += 4;
|
||||
} break;
|
||||
case OPCODE_CONSTRUCT: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
Variant::Type t = Variant::Type(_code_ptr[ip + 3 + instr_var_args]);
|
||||
int argc = _code_ptr[ip + 1 + instr_var_args];
|
||||
|
||||
|
|
@ -391,6 +391,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr = 3 + instr_var_args;
|
||||
} break;
|
||||
case OPCODE_CONSTRUCT_VALIDATED: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
int argc = _code_ptr[ip + 1 + instr_var_args];
|
||||
|
||||
text += "construct validated ";
|
||||
|
|
@ -409,6 +410,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr = 3 + instr_var_args;
|
||||
} break;
|
||||
case OPCODE_CONSTRUCT_ARRAY: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
int argc = _code_ptr[ip + 1 + instr_var_args];
|
||||
text += " make_array ";
|
||||
text += DADDR(1 + argc);
|
||||
|
|
@ -426,6 +428,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr += 3 + argc;
|
||||
} break;
|
||||
case OPCODE_CONSTRUCT_TYPED_ARRAY: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
int argc = _code_ptr[ip + 1 + instr_var_args];
|
||||
|
||||
Ref<Script> script_type = get_constant(_code_ptr[ip + argc + 2]);
|
||||
|
|
@ -460,6 +463,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr += 3 + argc;
|
||||
} break;
|
||||
case OPCODE_CONSTRUCT_DICTIONARY: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
int argc = _code_ptr[ip + 1 + instr_var_args];
|
||||
text += "make_dict ";
|
||||
text += DADDR(1 + argc * 2);
|
||||
|
|
@ -481,8 +485,10 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
case OPCODE_CALL:
|
||||
case OPCODE_CALL_RETURN:
|
||||
case OPCODE_CALL_ASYNC: {
|
||||
bool ret = (_code_ptr[ip] & INSTR_MASK) == OPCODE_CALL_RETURN;
|
||||
bool async = (_code_ptr[ip] & INSTR_MASK) == OPCODE_CALL_ASYNC;
|
||||
bool ret = (_code_ptr[ip]) == OPCODE_CALL_RETURN;
|
||||
bool async = (_code_ptr[ip]) == OPCODE_CALL_ASYNC;
|
||||
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
|
||||
if (ret) {
|
||||
text += "call-ret ";
|
||||
|
|
@ -513,7 +519,8 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
} break;
|
||||
case OPCODE_CALL_METHOD_BIND:
|
||||
case OPCODE_CALL_METHOD_BIND_RET: {
|
||||
bool ret = (_code_ptr[ip] & INSTR_MASK) == OPCODE_CALL_METHOD_BIND_RET;
|
||||
bool ret = (_code_ptr[ip]) == OPCODE_CALL_METHOD_BIND_RET;
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
|
||||
if (ret) {
|
||||
text += "call-method_bind-ret ";
|
||||
|
|
@ -543,6 +550,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr = 5 + argc;
|
||||
} break;
|
||||
case OPCODE_CALL_BUILTIN_STATIC: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
Variant::Type type = (Variant::Type)_code_ptr[ip + 1 + instr_var_args];
|
||||
int argc = _code_ptr[ip + 3 + instr_var_args];
|
||||
|
||||
|
|
@ -565,6 +573,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr += 5 + argc;
|
||||
} break;
|
||||
case OPCODE_CALL_NATIVE_STATIC: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
MethodBind *method = _methods_ptr[_code_ptr[ip + 1 + instr_var_args]];
|
||||
int argc = _code_ptr[ip + 2 + instr_var_args];
|
||||
|
||||
|
|
@ -587,6 +596,8 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr += 4 + argc;
|
||||
} break;
|
||||
case OPCODE_CALL_PTRCALL_NO_RETURN: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
|
||||
text += "call-ptrcall (no return) ";
|
||||
|
||||
MethodBind *method = _methods_ptr[_code_ptr[ip + 2 + instr_var_args]];
|
||||
|
|
@ -610,6 +621,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
|
||||
#define DISASSEMBLE_PTRCALL(m_type) \
|
||||
case OPCODE_CALL_PTRCALL_##m_type: { \
|
||||
int instr_var_args = _code_ptr[++ip]; \
|
||||
text += "call-ptrcall (return "; \
|
||||
text += #m_type; \
|
||||
text += ") "; \
|
||||
|
|
@ -667,6 +679,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
DISASSEMBLE_PTRCALL(PACKED_COLOR_ARRAY);
|
||||
|
||||
case OPCODE_CALL_BUILTIN_TYPE_VALIDATED: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
int argc = _code_ptr[ip + 1 + instr_var_args];
|
||||
|
||||
text += "call-builtin-method validated ";
|
||||
|
|
@ -689,6 +702,8 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr = 5 + argc;
|
||||
} break;
|
||||
case OPCODE_CALL_UTILITY: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
|
||||
text += "call-utility ";
|
||||
|
||||
int argc = _code_ptr[ip + 1 + instr_var_args];
|
||||
|
|
@ -708,6 +723,8 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr = 4 + argc;
|
||||
} break;
|
||||
case OPCODE_CALL_UTILITY_VALIDATED: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
|
||||
text += "call-utility ";
|
||||
|
||||
int argc = _code_ptr[ip + 1 + instr_var_args];
|
||||
|
|
@ -727,6 +744,8 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr = 4 + argc;
|
||||
} break;
|
||||
case OPCODE_CALL_GDSCRIPT_UTILITY: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
|
||||
text += "call-gscript-utility ";
|
||||
|
||||
int argc = _code_ptr[ip + 1 + instr_var_args];
|
||||
|
|
@ -746,6 +765,8 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr = 4 + argc;
|
||||
} break;
|
||||
case OPCODE_CALL_SELF_BASE: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
|
||||
text += "call-self-base ";
|
||||
|
||||
int argc = _code_ptr[ip + 1 + instr_var_args];
|
||||
|
|
@ -777,6 +798,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr = 2;
|
||||
} break;
|
||||
case OPCODE_CREATE_LAMBDA: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
int captures_count = _code_ptr[ip + 1 + instr_var_args];
|
||||
GDScriptFunction *lambda = _lambdas_ptr[_code_ptr[ip + 2 + instr_var_args]];
|
||||
|
||||
|
|
@ -796,6 +818,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
|||
incr = 3 + captures_count;
|
||||
} break;
|
||||
case OPCODE_CREATE_SELF_LAMBDA: {
|
||||
int instr_var_args = _code_ptr[++ip];
|
||||
int captures_count = _code_ptr[ip + 1 + instr_var_args];
|
||||
GDScriptFunction *lambda = _lambdas_ptr[_code_ptr[ip + 2 + instr_var_args]];
|
||||
|
||||
|
|
|
|||
|
|
@ -405,6 +405,7 @@ public:
|
|||
ADDR_TYPE_STACK = 0,
|
||||
ADDR_TYPE_CONSTANT = 1,
|
||||
ADDR_TYPE_MEMBER = 2,
|
||||
ADDR_TYPE_MAX = 3,
|
||||
};
|
||||
|
||||
enum FixedAddresses {
|
||||
|
|
@ -416,12 +417,6 @@ public:
|
|||
ADDR_NIL = ADDR_STACK_NIL | (ADDR_TYPE_STACK << ADDR_BITS),
|
||||
};
|
||||
|
||||
enum Instruction {
|
||||
INSTR_BITS = 20,
|
||||
INSTR_MASK = ((1 << INSTR_BITS) - 1),
|
||||
INSTR_ARGS_MASK = ~INSTR_MASK,
|
||||
};
|
||||
|
||||
struct StackDebug {
|
||||
int line;
|
||||
int pos;
|
||||
|
|
@ -514,7 +509,6 @@ private:
|
|||
|
||||
Variant _get_default_variant_for_data_type(const GDScriptDataType &p_data_type);
|
||||
|
||||
_FORCE_INLINE_ Variant *_get_variant(int p_address, GDScriptInstance *p_instance, Variant *p_stack, String &r_error) const;
|
||||
_FORCE_INLINE_ String _get_call_error(const Callable::CallError &p_err, const String &p_where, const Variant **argptrs) const;
|
||||
|
||||
friend class GDScriptLanguage;
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue