gdscript_byte_codegen.cpp | Explore in Territory

/**************************************************************************/
/*  gdscript_byte_codegen.cpp                                             */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "gdscript_byte_codegen.h"

#include "gdscript.h"

#include "core/debugger/engine_debugger.h"

uint32_t GDScriptByteCodeGenerator::add_parameter(const StringName &p_name, bool p_is_optional, const GDScriptDataType &p_type) { … }

uint32_t GDScriptByteCodeGenerator::add_local(const StringName &p_name, const GDScriptDataType &p_type) { … }

uint32_t GDScriptByteCodeGenerator::add_local_constant(const StringName &p_name, const Variant &p_constant) { … }

uint32_t GDScriptByteCodeGenerator::add_or_get_constant(const Variant &p_constant) { … }

uint32_t GDScriptByteCodeGenerator::add_or_get_name(const StringName &p_name) { … }

uint32_t GDScriptByteCodeGenerator::add_temporary(const GDScriptDataType &p_type) { … }

void GDScriptByteCodeGenerator::pop_temporary() { … }

void GDScriptByteCodeGenerator::start_parameters() { … }

void GDScriptByteCodeGenerator::end_parameters() { … }

void GDScriptByteCodeGenerator::write_start(GDScript *p_script, const StringName &p_function_name, bool p_static, Variant p_rpc_config, const GDScriptDataType &p_return_type) { … }

GDScriptFunction *GDScriptByteCodeGenerator::write_end() { … }

#ifdef DEBUG_ENABLED
void GDScriptByteCodeGenerator::set_signature(const String &p_signature) { … }
#endif

void GDScriptByteCodeGenerator::set_initial_line(int p_line) { … }

#define HAS_BUILTIN_TYPE(m_var) …

#define IS_BUILTIN_TYPE(m_var, m_type) …

void GDScriptByteCodeGenerator::write_type_adjust(const Address &p_target, Variant::Type p_new_type) { … }

void GDScriptByteCodeGenerator::write_unary_operator(const Address &p_target, Variant::Operator p_operator, const Address &p_left_operand) { … }

void GDScriptByteCodeGenerator::write_binary_operator(const Address &p_target, Variant::Operator p_operator, const Address &p_left_operand, const Address &p_right_operand) { … }

void GDScriptByteCodeGenerator::write_type_test(const Address &p_target, const Address &p_source, const GDScriptDataType &p_type) { … }

void GDScriptByteCodeGenerator::write_and_left_operand(const Address &p_left_operand) { … }

void GDScriptByteCodeGenerator::write_and_right_operand(const Address &p_right_operand) { … }

void GDScriptByteCodeGenerator::write_end_and(const Address &p_target) { … }

void GDScriptByteCodeGenerator::write_or_left_operand(const Address &p_left_operand) { … }

void GDScriptByteCodeGenerator::write_or_right_operand(const Address &p_right_operand) { … }

void GDScriptByteCodeGenerator::write_end_or(const Address &p_target) { … }

void GDScriptByteCodeGenerator::write_start_ternary(const Address &p_target) { … }

void GDScriptByteCodeGenerator::write_ternary_condition(const Address &p_condition) { … }

void GDScriptByteCodeGenerator::write_ternary_true_expr(const Address &p_expr) { … }

void GDScriptByteCodeGenerator::write_ternary_false_expr(const Address &p_expr) { … }

void GDScriptByteCodeGenerator::write_end_ternary() { … }

void GDScriptByteCodeGenerator::write_set(const Address &p_target, const Address &p_index, const Address &p_source) { … }

void GDScriptByteCodeGenerator::write_get(const Address &p_target, const Address &p_index, const Address &p_source) { … }

void GDScriptByteCodeGenerator::write_set_named(const Address &p_target, const StringName &p_name, const Address &p_source) { … }

void GDScriptByteCodeGenerator::write_get_named(const Address &p_target, const StringName &p_name, const Address &p_source) { … }

void GDScriptByteCodeGenerator::write_set_member(const Address &p_value, const StringName &p_name) { … }

void GDScriptByteCodeGenerator::write_get_member(const Address &p_target, const StringName &p_name) { … }

void GDScriptByteCodeGenerator::write_set_static_variable(const Address &p_value, const Address &p_class, int p_index) { … }

void GDScriptByteCodeGenerator::write_get_static_variable(const Address &p_target, const Address &p_class, int p_index) { … }

void GDScriptByteCodeGenerator::write_assign_with_conversion(const Address &p_target, const Address &p_source) { … }

void GDScriptByteCodeGenerator::write_assign(const Address &p_target, const Address &p_source) { … }

void GDScriptByteCodeGenerator::write_assign_null(const Address &p_target) { … }

void GDScriptByteCodeGenerator::write_assign_true(const Address &p_target) { … }

void GDScriptByteCodeGenerator::write_assign_false(const Address &p_target) { … }

void GDScriptByteCodeGenerator::write_assign_default_parameter(const Address &p_dst, const Address &p_src, bool p_use_conversion) { … }

void GDScriptByteCodeGenerator::write_store_global(const Address &p_dst, int p_global_index) { … }

void GDScriptByteCodeGenerator::write_store_named_global(const Address &p_dst, const StringName &p_global) { … }

void GDScriptByteCodeGenerator::write_cast(const Address &p_target, const Address &p_source, const GDScriptDataType &p_type) { … }

GDScriptByteCodeGenerator::CallTarget GDScriptByteCodeGenerator::get_call_target(const GDScriptCodeGenerator::Address &p_target, Variant::Type p_type) { … }

void GDScriptByteCodeGenerator::write_call(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_super_call(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_async(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_gdscript_utility(const Address &p_target, const StringName &p_function, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_utility(const Address &p_target, const StringName &p_function, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, bool p_is_static, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_builtin_type_static(const Address &p_target, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_native_static(const Address &p_target, const StringName &p_class, const StringName &p_method, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_native_static_validated(const GDScriptCodeGenerator::Address &p_target, MethodBind *p_method, const Vector<GDScriptCodeGenerator::Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_method_bind(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_method_bind_validated(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_self(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_self_async(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_call_script_function(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_lambda(const Address &p_target, GDScriptFunction *p_function, const Vector<Address> &p_captures, bool p_use_self) { … }

void GDScriptByteCodeGenerator::write_construct(const Address &p_target, Variant::Type p_type, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_construct_array(const Address &p_target, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_construct_typed_array(const Address &p_target, const GDScriptDataType &p_element_type, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_construct_dictionary(const Address &p_target, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_construct_typed_dictionary(const Address &p_target, const GDScriptDataType &p_key_type, const GDScriptDataType &p_value_type, const Vector<Address> &p_arguments) { … }

void GDScriptByteCodeGenerator::write_await(const Address &p_target, const Address &p_operand) { … }

void GDScriptByteCodeGenerator::write_if(const Address &p_condition) { … }

void GDScriptByteCodeGenerator::write_else() { … }

void GDScriptByteCodeGenerator::write_endif() { … }

void GDScriptByteCodeGenerator::write_jump_if_shared(const Address &p_value) { … }

void GDScriptByteCodeGenerator::write_end_jump_if_shared() { … }

void GDScriptByteCodeGenerator::start_for(const GDScriptDataType &p_iterator_type, const GDScriptDataType &p_list_type) { … }

void GDScriptByteCodeGenerator::write_for_assignment(const Address &p_list) { … }

void GDScriptByteCodeGenerator::write_for(const Address &p_variable, bool p_use_conversion) { … }

void GDScriptByteCodeGenerator::write_endfor() { … }

void GDScriptByteCodeGenerator::start_while_condition() { … }

void GDScriptByteCodeGenerator::write_while(const Address &p_condition) { … }

void GDScriptByteCodeGenerator::write_endwhile() { … }

void GDScriptByteCodeGenerator::write_break() { … }

void GDScriptByteCodeGenerator::write_continue() { … }

void GDScriptByteCodeGenerator::write_breakpoint() { … }

void GDScriptByteCodeGenerator::write_newline(int p_line) { … }

void GDScriptByteCodeGenerator::write_return(const Address &p_return_value) { … }

void GDScriptByteCodeGenerator::write_assert(const Address &p_test, const Address &p_message) { … }

void GDScriptByteCodeGenerator::start_block() { … }

void GDScriptByteCodeGenerator::end_block() { … }

void GDScriptByteCodeGenerator::clear_temporaries() { … }

void GDScriptByteCodeGenerator::clear_address(const Address &p_address) { … }

// Returns `true` if the local has been reused and not cleaned up with `clear_address()`.
bool GDScriptByteCodeGenerator::is_local_dirty(const Address &p_address) const { … }

GDScriptByteCodeGenerator::~GDScriptByteCodeGenerator() { … }
godot/modules/gdscript/gdscript_byte_codegen.cpp
