+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */

+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */

+#include "core/os/keyboard.h"

+#include "editor/editor_internal_calls.h"

+#include "editor/editor_settings.h"

+#include "editor/script_templates/templates.gen.h"

+ p_keyword == "case" ||

+ p_keyword == "catch" ||

+ p_keyword == "continue" ||

+ p_keyword == "default" ||

+ p_keyword == "do" ||

+ p_keyword == "else" ||

+ p_keyword == "finally" ||

+ p_keyword == "for" ||

+ p_keyword == "foreach" ||

+ p_keyword == "goto" ||

+ p_keyword == "if" ||

+ p_keyword == "return" ||

+ p_keyword == "switch" ||

+ p_keyword == "throw" ||

+ p_keyword == "try" ||

+ p_keyword == "while";

+ p_delimiters->push_back("@\" \""); // verbatim string literal

+bool CSharpLanguage::is_using_templates() {

+ return true;

+}

+Ref<Script> CSharpLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {

+ String class_name_no_spaces = p_class_name.replace(" ", "_");

+ String base_class_name = get_base_class_name(p_base_class_name, class_name_no_spaces);

+ String processed_template = p_template;

+ processed_template = processed_template.replace("_BINDINGS_NAMESPACE_", BINDINGS_NAMESPACE)

+ .replace("_BASE_", base_class_name)

+ .replace("_CLASS_", class_name_no_spaces)

+ .replace("_TS_", _get_indentation());

+ script->set_source_code(processed_template);

+Vector<ScriptLanguage::ScriptTemplate> CSharpLanguage::get_built_in_templates(StringName p_object) {

+ Vector<ScriptLanguage::ScriptTemplate> templates;

+#ifdef TOOLS_ENABLED

+ for (int i = 0; i < TEMPLATES_ARRAY_SIZE; i++) {

+ if (TEMPLATES[i].inherit == p_object) {

+ templates.append(TEMPLATES[i]);

+ }

+ }

+#endif

+ return templates;

+ return RTR("Class name can't be a reserved keyword");

+ Variant::VECTOR4,

+ Variant::VECTOR4I,

+ Variant::PROJECTION,

+ bool use_space_indentation = EDITOR_GET("text_editor/behavior/indent/type");

+ int indent_size = EDITOR_GET("text_editor/behavior/indent/size");

+ HashMap<ObjectID, int>::Iterator elem = unsafe_object_references.find(id);

+ if (--elem->value == 0) {

+ unsafe_object_references.remove(elem);

+ String appname_safe = ProjectSettings::get_singleton()->get_safe_project_name();

+ for (Object *obj : script->instances) {

+ for (PlaceHolderScriptInstance *script_instance : script->placeholders) {

+ RBMap<ObjectID, CSharpScript::StateBackup> &owners_map = script->pending_reload_state;

+ for (Object *obj : script->instances) {

+ while (script->instances.begin()) {

+ Object *obj = *script->instances.begin();

+ obj->set_script(Ref<RefCounted>()); // Remove script and existing script instances (placeholder are not removed before domain reload)

+ HashMap<StringName, CSharpScript::EventSignal>::Iterator match = script->event_signals.find(name);

+ const CSharpScript::EventSignal &event_signal = match->value;

+ InspectorDock::get_inspector_singleton()->update_tree();

+ NodeDock::get_singleton()->update_lists();

+ ED_SHORTCUT("mono/build_solution", TTR("Build Solution"), KeyModifierMask::ALT | Key::B);

+RBMap<Object *, CSharpScriptBinding>::Element *CSharpLanguage::insert_script_binding(Object *p_object, const CSharpScriptBinding &p_script_binding) {

+ RBMap<Object *, CSharpScriptBinding>::Element *match = csharp_lang->script_bindings.find((Object *)p_instance);

+ RBMap<Object *, CSharpScriptBinding>::Element *data = (RBMap<Object *, CSharpScriptBinding>::Element *)p_binding;

+ CSharpScriptBinding &script_binding = ((RBMap<Object *, CSharpScriptBinding>::Element *)p_binding)->get();

+ CSharpScriptBinding &script_binding = ((RBMap<Object *, CSharpScriptBinding>::Element *)binding)->value();

+ property->set_value_from_variant(mono_object, p_value);

+ GDMonoField *field = nullptr;

+ GDMonoClass *top = script->script_class;

+ while (top && top != script->native) {

+ field = top->get_field(state_pair.first);

+ if (field) {

+ break;

+ }

+

+ top = top->get_parent_class();

+ }

+ List<PropertyInfo> props;

+ script->get_script_property_list(&props);

+ props.push_back(PropertyInfo::from_dict(array.get(i)));

+

+ for (const PropertyInfo &prop : props) {

+ p_properties->push_back(prop);

+ }

+void CSharpInstance::get_method_list(List<MethodInfo> *p_list) const {

+ if (!script->is_valid() || !script->script_class) {

+ return;

+ }

+

+ GD_MONO_SCOPE_THREAD_ATTACH;

+

+ // TODO: We're filtering out constructors but there may be other methods unsuitable for explicit calls.

+ GDMonoClass *top = script->script_class;

+

+ while (top && top != script->native) {

+ const Vector<GDMonoMethod *> &methods = top->get_all_methods();

+ for (int i = 0; i < methods.size(); ++i) {

+ MethodInfo minfo = methods[i]->get_method_info();

+ if (minfo.name != CACHED_STRING_NAME(dotctor)) {

+ p_list->push_back(minfo);

+ }

+ }

+

+ top = top->get_parent_class();

+ }

+}

+

+Variant CSharpInstance::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {

+const Variant CSharpInstance::get_rpc_config() const {

+ return script->get_rpc_config();

+ CSharpScriptBinding &script_binding = ((RBMap<Object *, CSharpScriptBinding>::Element *)data)->get();

+ HashSet<Object *>::Iterator match = script->instances.find(owner);

+ script->instances.remove(match);

+void CSharpScript::_update_exports_values(HashMap<StringName, Variant> &values, List<PropertyInfo> &propnames) {

+

+ if (base_cache.is_valid()) {

+ base_cache->_update_exports_values(values, propnames);

+ }

+ List<PropertyInfo> props;

+ props.push_front(prop_info);

+ props.push_front(prop_info);

+ exported_members_cache.push_back(PropertyInfo(Variant::NIL, top->get_name(), PROPERTY_HINT_NONE, get_path(), PROPERTY_USAGE_CATEGORY));

+ for (const PropertyInfo &E : props) {

+ exported_members_cache.push_back(E);

+ }

+

+ props.clear();

+

+ List<PropertyInfo> props;

+ props.push_front(prop_info);

+ props.push_front(prop_info);

+#ifdef TOOLS_ENABLED

+ exported_members_cache.push_back(PropertyInfo(Variant::NIL, top->get_name(), PROPERTY_HINT_NONE, get_path(), PROPERTY_USAGE_CATEGORY));

+

+ for (const PropertyInfo &E : props) {

+ exported_members_cache.push_back(E);

+ }

+

+ props.clear();

+#endif // TOOLS_ENABLED

+

+ HashMap<StringName, Variant> values;

+ for (PlaceHolderScriptInstance *script_instance : placeholders) {

+ MonoReflectionType *reftype = mono_type_get_object(mono_domain_get(), p_type.type_class->get_mono_type());

+ r_hint = GDMonoUtils::Marshal::type_has_flags_attribute(reftype) ? PROPERTY_HINT_FLAGS : PROPERTY_HINT_ENUM;

+ unsigned int expected_val = r_hint == PROPERTY_HINT_FLAGS ? 1 << i : i;

+ if (val != expected_val) {

+ } else if (p_variant_type == Variant::OBJECT && CACHED_CLASS(Node)->is_assignable_from(p_type.type_class)) {

+ GDMonoClass *field_native_class = GDMonoUtils::get_class_native_base(p_type.type_class);

+ CRASH_COND(field_native_class == nullptr);

+

+ r_hint = PROPERTY_HINT_NODE_TYPE;

+ r_hint_string = String(NATIVE_GDMONOCLASS_NAME(field_native_class));

+ bool preset_hint = false;

+ if (elem_variant_type == Variant::STRING) {

+ MonoObject *attr = p_member->get_attribute(CACHED_CLASS(ExportAttribute));

+ if (PropertyHint(CACHED_FIELD(ExportAttribute, hint)->get_int_value(attr)) == PROPERTY_HINT_ENUM) {

+ r_hint_string = itos(elem_variant_type) + "/" + itos(PROPERTY_HINT_ENUM) + ":" + CACHED_FIELD(ExportAttribute, hintString)->get_string_value(attr);

+ preset_hint = true;

+ }

+ }

+

+ if (!preset_hint) {

+ int hint_res = _try_get_member_export_hint(p_member, elem_type, elem_variant_type, /* allow_generics: */ false, elem_hint, elem_hint_string);

+ ERR_FAIL_COND_V_MSG(hint_res == -1, -1, "Error while trying to determine information about the array element type.");

+

+ // Format: type/hint:hint_string

+ r_hint_string = itos(elem_variant_type) + "/" + itos(elem_hint) + ":" + elem_hint_string;

+ }

+Variant CSharpScript::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {

+ return Script::callp(p_method, p_args, p_argcount, r_error);

+ p_properties->push_back(PropertyInfo(Variant::STRING, CSharpLanguage::singleton->string_names._script_source, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL));

+ p_script->reload_invalidated = false;

+ p_script->rpc_config.clear();

+ const Variant rpc_config = p_script->_member_get_rpc_config(methods[i]);

+ if (rpc_config.get_type() != Variant::NIL) {

+ p_script->rpc_config[methods[i]->get_name()] = rpc_config;

+ CSharpScriptBinding &script_binding = ((RBMap<Object *, CSharpScriptBinding>::Element *)data)->get();

+ Ref<RefCounted> ref;

+ ref = Ref<RefCounted>(r);

+ GD_MONO_SCOPE_THREAD_ATTACH;

+

+ ERR_FAIL_V_MSG(nullptr, "Script inherits from native type '" + String(native_name) + "', so it can't be instantiated in object of type: '" + p_this->get_class() + "'.");

+ // TODO: We're filtering out constructors but there may be other methods unsuitable for explicit calls.

+ GDMonoClass *top = script_class;

+

+ while (top && top != native) {

+ const Vector<GDMonoMethod *> &methods = top->get_all_methods();

+ for (int i = 0; i < methods.size(); ++i) {

+ MethodInfo minfo = methods[i]->get_method_info();

+ if (minfo.name != CACHED_STRING_NAME(dotctor)) {

+ p_list->push_back(methods[i]->get_method_info());

+ }

+ }

+

+ top = top->get_parent_class();

+ if (!reload_invalidated) {

+ return OK;

+ // In the case of C#, reload doesn't really do any script reloading.

+ // That's done separately via domain reloading.

+ reload_invalidated = false;

+ HashMap<StringName, Variant>::ConstIterator E = exported_members_defval_cache.find(p_property);

+ r_value = E->value;

+void CSharpScript::get_script_property_list(List<PropertyInfo> *r_list) const {

+ List<PropertyInfo> props;

+

+#ifdef TOOLS_ENABLED

+ for (const PropertyInfo &E : exported_members_cache) {

+ props.push_back(E);

+ }

+#else

+ props.push_front(E.value);

+ }

+#endif // TOOLS_ENABLED

+

+ for (const PropertyInfo &prop : props) {

+ r_list->push_back(prop);

+Variant CSharpScript::_member_get_rpc_config(IMonoClassMember *p_member) const {

+ Variant out;

+

+ MonoObject *rpc_attribute = p_member->get_attribute(CACHED_CLASS(RPCAttribute));

+ if (rpc_attribute != nullptr) {

+ Dictionary rpc_config;

+ rpc_config["rpc_mode"] = CACHED_PROPERTY(RPCAttribute, Mode)->get_int_value(rpc_attribute);

+ rpc_config["call_local"] = CACHED_PROPERTY(RPCAttribute, CallLocal)->get_bool_value(rpc_attribute);

+ rpc_config["transfer_mode"] = CACHED_PROPERTY(RPCAttribute, TransferMode)->get_int_value(rpc_attribute);

+ rpc_config["channel"] = CACHED_PROPERTY(RPCAttribute, TransferChannel)->get_int_value(rpc_attribute);

+ out = rpc_config;

+ return out;

+const Variant CSharpScript::get_rpc_config() const {

+ return rpc_config;

+ ferr == ERR_INVALID_DATA

+ ? "Script '" + p_path + "' contains invalid unicode (UTF-8), so it was not loaded."

+ " Please ensure that scripts are saved in valid UTF-8 unicode."

+ : "Failed to read file: '" + p_path + "'.");

+ reload_invalidated = true;

+void CSharpScript::get_members(HashSet<StringName> *p_members) {

+Ref<Resource> ResourceFormatLoaderCSharpScript::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) {

+ ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Cannot load C# script file '" + p_path + "'.");

+Error ResourceFormatSaverCSharpScript::save(const Ref<Resource> &p_resource, const String &p_path, uint32_t p_flags) {

+ {

+ Error err;

+ Ref<FileAccess> file = FileAccess::open(p_path, FileAccess::WRITE, &err);

+ ERR_FAIL_COND_V_MSG(err != OK, err, "Cannot save C# script file '" + p_path + "'.");

+ file->store_string(source);

+ if (file->get_error() != OK && file->get_error() != ERR_FILE_EOF) {

+ return ERR_CANT_CREATE;

+ }

+void ResourceFormatSaverCSharpScript::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {

+bool ResourceFormatSaverCSharpScript::recognize(const Ref<Resource> &p_resource) const {