gdscript.cpp | Explore in Territory

/**************************************************************************/
/*  gdscript.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.h"

#include "gdscript_analyzer.h"
#include "gdscript_cache.h"
#include "gdscript_compiler.h"
#include "gdscript_parser.h"
#include "gdscript_rpc_callable.h"
#include "gdscript_tokenizer_buffer.h"
#include "gdscript_warning.h"

#ifdef TOOLS_ENABLED
#include "editor/gdscript_docgen.h"
#endif

#ifdef TESTS_ENABLED
#include "tests/gdscript_test_runner.h"
#endif

#include "core/config/engine.h"
#include "core/config/project_settings.h"
#include "core/core_constants.h"
#include "core/io/file_access.h"
#include "core/io/file_access_encrypted.h"
#include "core/os/os.h"

#include "scene/resources/packed_scene.h"
#include "scene/scene_string_names.h"

#ifdef TOOLS_ENABLED
#include "core/extension/gdextension_manager.h"
#include "editor/editor_paths.h"
#endif

#include <stdint.h>

///////////////////////////

GDScriptNativeClass::GDScriptNativeClass(const StringName &p_name) { … }

bool GDScriptNativeClass::_get(const StringName &p_name, Variant &r_ret) const { … }

void GDScriptNativeClass::_bind_methods() { … }

Variant GDScriptNativeClass::_new() { … }

Object *GDScriptNativeClass::instantiate() { … }

Variant GDScriptNativeClass::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) { … }

GDScriptFunction *GDScript::_super_constructor(GDScript *p_script) { … }

void GDScript::_super_implicit_constructor(GDScript *p_script, GDScriptInstance *p_instance, Callable::CallError &r_error) { … }

GDScriptInstance *GDScript::_create_instance(const Variant **p_args, int p_argcount, Object *p_owner, bool p_is_ref_counted, Callable::CallError &r_error) { … }

Variant GDScript::_new(const Variant **p_args, int p_argcount, Callable::CallError &r_error) { … }

bool GDScript::can_instantiate() const { … }

Ref<Script> GDScript::get_base_script() const { … }

StringName GDScript::get_global_name() const { … }

StringName GDScript::get_instance_base_type() const { … }

struct _GDScriptMemberSort { … };

#ifdef TOOLS_ENABLED

void GDScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) { … }

#endif

void GDScript::_get_script_method_list(List<MethodInfo> *r_list, bool p_include_base) const { … }

void GDScript::get_script_method_list(List<MethodInfo> *r_list) const { … }

void GDScript::_get_script_property_list(List<PropertyInfo> *r_list, bool p_include_base) const { … }

void GDScript::get_script_property_list(List<PropertyInfo> *r_list) const { … }

bool GDScript::has_method(const StringName &p_method) const { … }

bool GDScript::has_static_method(const StringName &p_method) const { … }

int GDScript::get_script_method_argument_count(const StringName &p_method, bool *r_is_valid) const { … }

MethodInfo GDScript::get_method_info(const StringName &p_method) const { … }

bool GDScript::get_property_default_value(const StringName &p_property, Variant &r_value) const { … }

ScriptInstance *GDScript::instance_create(Object *p_this) { … }

PlaceHolderScriptInstance *GDScript::placeholder_instance_create(Object *p_this) { … }

bool GDScript::instance_has(const Object *p_this) const { … }

bool GDScript::has_source_code() const { … }

String GDScript::get_source_code() const { … }

void GDScript::set_source_code(const String &p_code) { … }

#ifdef TOOLS_ENABLED
void GDScript::_update_exports_values(HashMap<StringName, Variant> &values, List<PropertyInfo> &propnames) { … }

void GDScript::_add_doc(const DocData::ClassDoc &p_inner_class) { … }

void GDScript::_clear_doc() { … }

String GDScript::get_class_icon_path() const { … }
#endif

bool GDScript::_update_exports(bool *r_err, bool p_recursive_call, PlaceHolderScriptInstance *p_instance_to_update, bool p_base_exports_changed) { … }

void GDScript::update_exports() { … }

#ifdef TOOLS_ENABLED
void GDScript::_update_exports_down(bool p_base_exports_changed) { … }
#endif

String GDScript::_get_debug_path() const { … }

Error GDScript::_static_init() { … }

void GDScript::_static_default_init() { … }

#ifdef TOOLS_ENABLED

void GDScript::_save_old_static_data() { … }

void GDScript::_restore_old_static_data() { … }

#endif

Error GDScript::reload(bool p_keep_state) { … }

ScriptLanguage *GDScript::get_language() const { … }

void GDScript::get_constants(HashMap<StringName, Variant> *p_constants) { … }

void GDScript::get_members(HashSet<StringName> *p_members) { … }

Variant GDScript::get_rpc_config() const { … }

void GDScript::unload_static() const { … }

Variant GDScript::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) { … }

bool GDScript::_get(const StringName &p_name, Variant &r_ret) const { … }

bool GDScript::_set(const StringName &p_name, const Variant &p_value) { … }

void GDScript::_get_property_list(List<PropertyInfo> *p_properties) const { … }

void GDScript::_bind_methods() { … }

void GDScript::set_path_cache(const String &p_path) { … }

void GDScript::set_path(const String &p_path, bool p_take_over) { … }

String GDScript::get_script_path() const { … }

Error GDScript::load_source_code(const String &p_path) { … }

void GDScript::set_binary_tokens_source(const Vector<uint8_t> &p_binary_tokens) { … }

const Vector<uint8_t> &GDScript::get_binary_tokens_source() const { … }

Vector<uint8_t> GDScript::get_as_binary_tokens() const { … }

const HashMap<StringName, GDScriptFunction *> &GDScript::debug_get_member_functions() const { … }

StringName GDScript::debug_get_member_by_index(int p_idx) const { … }

StringName GDScript::debug_get_static_var_by_index(int p_idx) const { … }

Ref<GDScript> GDScript::get_base() const { … }

bool GDScript::inherits_script(const Ref<Script> &p_script) const { … }

GDScript *GDScript::find_class(const String &p_qualified_name) { … }

bool GDScript::has_class(const GDScript *p_script) { … }

GDScript *GDScript::get_root_script() { … }

RBSet<GDScript *> GDScript::get_dependencies() { … }

HashMap<GDScript *, RBSet<GDScript *>> GDScript::get_all_dependencies() { … }

RBSet<GDScript *> GDScript::get_must_clear_dependencies() { … }

bool GDScript::has_script_signal(const StringName &p_signal) const { … }

void GDScript::_get_script_signal_list(List<MethodInfo> *r_list, bool p_include_base) const { … }

void GDScript::get_script_signal_list(List<MethodInfo> *r_signals) const { … }

GDScript *GDScript::_get_gdscript_from_variant(const Variant &p_variant) { … }

void GDScript::_collect_function_dependencies(GDScriptFunction *p_func, RBSet<GDScript *> &p_dependencies, const GDScript *p_except) { … }

void GDScript::_collect_dependencies(RBSet<GDScript *> &p_dependencies, const GDScript *p_except) { … }

GDScript::GDScript() : … { … }

void GDScript::_save_orphaned_subclasses(ClearData *p_clear_data) { … }

#ifdef DEBUG_ENABLED
String GDScript::debug_get_script_name(const Ref<Script> &p_script) { … }
#endif

String GDScript::canonicalize_path(const String &p_path) { … }

GDScript::UpdatableFuncPtr::UpdatableFuncPtr(GDScriptFunction *p_function) { … }

GDScript::UpdatableFuncPtr::~UpdatableFuncPtr() { … }

void GDScript::_recurse_replace_function_ptrs(const HashMap<GDScriptFunction *, GDScriptFunction *> &p_replacements) const { … }

void GDScript::clear(ClearData *p_clear_data) { … }

GDScript::~GDScript() { … }

//////////////////////////////
//         INSTANCE         //
//////////////////////////////

bool GDScriptInstance::set(const StringName &p_name, const Variant &p_value) { … }

bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const { … }

Variant::Type GDScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const { … }

void GDScriptInstance::validate_property(PropertyInfo &p_property) const { … }

void GDScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const { … }

bool GDScriptInstance::property_can_revert(const StringName &p_name) const { … }

bool GDScriptInstance::property_get_revert(const StringName &p_name, Variant &r_ret) const { … }

void GDScriptInstance::get_method_list(List<MethodInfo> *p_list) const { … }

bool GDScriptInstance::has_method(const StringName &p_method) const { … }

int GDScriptInstance::get_method_argument_count(const StringName &p_method, bool *r_is_valid) const { … }

void GDScriptInstance::_call_implicit_ready_recursively(GDScript *p_script) { … }

Variant GDScriptInstance::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) { … }

void GDScriptInstance::notification(int p_notification, bool p_reversed) { … }

String GDScriptInstance::to_string(bool *r_valid) { … }

Ref<Script> GDScriptInstance::get_script() const { … }

ScriptLanguage *GDScriptInstance::get_language() { … }

const Variant GDScriptInstance::get_rpc_config() const { … }

void GDScriptInstance::reload_members() { … }

GDScriptInstance::GDScriptInstance() { … }

GDScriptInstance::~GDScriptInstance() { … }

/************* SCRIPT LANGUAGE **************/

GDScriptLanguage *GDScriptLanguage::singleton = …;

String GDScriptLanguage::get_name() const { … }

/* LANGUAGE FUNCTIONS */

void GDScriptLanguage::_add_global(const StringName &p_name, const Variant &p_value) { … }

void GDScriptLanguage::_remove_global(const StringName &p_name) { … }

void GDScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) { … }

void GDScriptLanguage::add_named_global_constant(const StringName &p_name, const Variant &p_value) { … }

Variant GDScriptLanguage::get_any_global_constant(const StringName &p_name) { … }

void GDScriptLanguage::remove_named_global_constant(const StringName &p_name) { … }

void GDScriptLanguage::init() { … }

#ifdef TOOLS_ENABLED
void GDScriptLanguage::_extension_loaded(const Ref<GDExtension> &p_extension) { … }

void GDScriptLanguage::_extension_unloading(const Ref<GDExtension> &p_extension) { … }
#endif

String GDScriptLanguage::get_type() const { … }

String GDScriptLanguage::get_extension() const { … }

void GDScriptLanguage::finish() { … }

void GDScriptLanguage::profiling_start() { … }

void GDScriptLanguage::profiling_set_save_native_calls(bool p_enable) { … }

void GDScriptLanguage::profiling_stop() { … }

int GDScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) { … }

int GDScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) { … }

void GDScriptLanguage::profiling_collate_native_call_data(bool p_accumulated) { … }

struct GDScriptDepSort { … };

void GDScriptLanguage::reload_all_scripts() { … }

void GDScriptLanguage::reload_scripts(const Array &p_scripts, bool p_soft_reload) { … }

void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) { … }

void GDScriptLanguage::frame() { … }

/* EDITOR FUNCTIONS */
void GDScriptLanguage::get_reserved_words(List<String> *p_words) const { … }

bool GDScriptLanguage::is_control_flow_keyword(const String &p_keyword) const { … }

bool GDScriptLanguage::handles_global_class_type(const String &p_type) const { … }

String GDScriptLanguage::get_global_class_name(const String &p_path, String *r_base_type, String *r_icon_path) const { … }

thread_local GDScriptLanguage::CallStack GDScriptLanguage::_call_stack;

GDScriptLanguage::GDScriptLanguage() { … }

GDScriptLanguage::~GDScriptLanguage() { … }

void GDScriptLanguage::add_orphan_subclass(const String &p_qualified_name, const ObjectID &p_subclass) { … }

Ref<GDScript> GDScriptLanguage::get_orphan_subclass(const String &p_qualified_name) { … }

Ref<GDScript> GDScriptLanguage::get_script_by_fully_qualified_name(const String &p_name) { … }

/*************** RESOURCE ***************/

Ref<Resource> ResourceFormatLoaderGDScript::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) { … }

void ResourceFormatLoaderGDScript::get_recognized_extensions(List<String> *p_extensions) const { … }

bool ResourceFormatLoaderGDScript::handles_type(const String &p_type) const { … }

String ResourceFormatLoaderGDScript::get_resource_type(const String &p_path) const { … }

void ResourceFormatLoaderGDScript::get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types) { … }

Error ResourceFormatSaverGDScript::save(const Ref<Resource> &p_resource, const String &p_path, uint32_t p_flags) { … }

void ResourceFormatSaverGDScript::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const { … }

bool ResourceFormatSaverGDScript::recognize(const Ref<Resource> &p_resource) const { … }
godot/modules/gdscript/gdscript.cpp
