This source generator adds a newly introduced attribute, `ScriptPath` to all classes that: - Are top-level classes (not inner/nested). - Have the `partial` modifier. - Inherit `Godot.Object`. - The class name matches the file name. A build error is thrown if the generator finds a class that meets these conditions but is not declared `partial`, unless the class is annotated with the `DisableGodotGenerators` attribute. We also generate an `AssemblyHasScripts` assembly attribute which Godot uses to get all the script classes in the assembly, eliminating the need for Godot to search them. We can also avoid searching in assemblies that don't have this attribute. This will be good for performance in the future once we support multiple assemblies with Godot script classes. This is an example of what the generated code looks like: ``` using Godot; namespace Foo { [ScriptPathAttribute("res://Player.cs")] // Multiple partial declarations are allowed [ScriptPathAttribute("res://Foo/Player.cs")] partial class Player {} } [assembly:AssemblyHasScripts(new System.Type[] { typeof(Foo.Player) })] ``` The new attributes replace script metadata which we were generating by determining the namespace of script classes with a very simple parser. This fixes several issues with the old approach related to parser errors and conditional compilation. It also makes the task part of the MSBuild project build, rather than a separate step executed by the Godot editor.
482 lines
16 KiB
C++
482 lines
16 KiB
C++
/*************************************************************************/
|
|
/* gd_mono_assembly.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* */
|
|
/* 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 "gd_mono_assembly.h"
|
|
|
|
#include <mono/metadata/mono-debug.h>
|
|
#include <mono/metadata/tokentype.h>
|
|
|
|
#include "core/config/project_settings.h"
|
|
#include "core/io/file_access_pack.h"
|
|
#include "core/os/file_access.h"
|
|
#include "core/os/os.h"
|
|
#include "core/templates/list.h"
|
|
|
|
#include "../godotsharp_dirs.h"
|
|
#include "gd_mono_cache.h"
|
|
#include "gd_mono_class.h"
|
|
|
|
Vector<String> GDMonoAssembly::search_dirs;
|
|
|
|
void GDMonoAssembly::fill_search_dirs(Vector<String> &r_search_dirs, const String &p_custom_config, const String &p_custom_bcl_dir) {
|
|
String framework_dir;
|
|
|
|
if (!p_custom_bcl_dir.is_empty()) {
|
|
framework_dir = p_custom_bcl_dir;
|
|
} else if (mono_assembly_getrootdir()) {
|
|
framework_dir = String::utf8(mono_assembly_getrootdir()).plus_file("mono").plus_file("4.5");
|
|
}
|
|
|
|
if (!framework_dir.is_empty()) {
|
|
r_search_dirs.push_back(framework_dir);
|
|
r_search_dirs.push_back(framework_dir.plus_file("Facades"));
|
|
}
|
|
|
|
#if !defined(TOOLS_ENABLED)
|
|
String data_game_assemblies_dir = GodotSharpDirs::get_data_game_assemblies_dir();
|
|
if (!data_game_assemblies_dir.is_empty()) {
|
|
r_search_dirs.push_back(data_game_assemblies_dir);
|
|
}
|
|
#endif
|
|
|
|
if (p_custom_config.length()) {
|
|
r_search_dirs.push_back(GodotSharpDirs::get_res_temp_assemblies_base_dir().plus_file(p_custom_config));
|
|
} else {
|
|
r_search_dirs.push_back(GodotSharpDirs::get_res_temp_assemblies_dir());
|
|
}
|
|
|
|
if (p_custom_config.is_empty()) {
|
|
r_search_dirs.push_back(GodotSharpDirs::get_res_assemblies_dir());
|
|
} else {
|
|
String api_config = p_custom_config == "ExportRelease" ? "Release" : "Debug";
|
|
r_search_dirs.push_back(GodotSharpDirs::get_res_assemblies_base_dir().plus_file(api_config));
|
|
}
|
|
|
|
r_search_dirs.push_back(GodotSharpDirs::get_res_assemblies_base_dir());
|
|
r_search_dirs.push_back(OS::get_singleton()->get_resource_dir());
|
|
r_search_dirs.push_back(OS::get_singleton()->get_executable_path().get_base_dir());
|
|
|
|
#ifdef TOOLS_ENABLED
|
|
r_search_dirs.push_back(GodotSharpDirs::get_data_editor_tools_dir());
|
|
|
|
// For GodotTools to find the api assemblies
|
|
r_search_dirs.push_back(GodotSharpDirs::get_data_editor_prebuilt_api_dir().plus_file("Debug"));
|
|
#endif
|
|
}
|
|
|
|
// This is how these assembly loading hooks work:
|
|
//
|
|
// - The 'search' hook checks if the assembly has already been loaded, to avoid loading again.
|
|
// - The 'preload' hook does the actual loading and is only called if the
|
|
// 'search' hook didn't find the assembly in the list of loaded assemblies.
|
|
// - The 'load' hook is called after the assembly has been loaded. Its job is to add the
|
|
// assembly to the list of loaded assemblies so that the 'search' hook can look it up.
|
|
|
|
void GDMonoAssembly::assembly_load_hook(MonoAssembly *assembly, [[maybe_unused]] void *user_data) {
|
|
String name = String::utf8(mono_assembly_name_get_name(mono_assembly_get_name(assembly)));
|
|
|
|
MonoImage *image = mono_assembly_get_image(assembly);
|
|
|
|
GDMonoAssembly *gdassembly = memnew(GDMonoAssembly(name, image, assembly));
|
|
|
|
#ifdef GD_MONO_HOT_RELOAD
|
|
String path = String::utf8(mono_image_get_filename(image));
|
|
if (FileAccess::exists(path)) {
|
|
gdassembly->modified_time = FileAccess::get_modified_time(path);
|
|
}
|
|
#endif
|
|
|
|
MonoDomain *domain = mono_domain_get();
|
|
GDMono::get_singleton()->add_assembly(domain ? mono_domain_get_id(domain) : 0, gdassembly);
|
|
}
|
|
|
|
MonoAssembly *GDMonoAssembly::assembly_search_hook(MonoAssemblyName *aname, void *user_data) {
|
|
return GDMonoAssembly::_search_hook(aname, user_data, false);
|
|
}
|
|
|
|
MonoAssembly *GDMonoAssembly::assembly_refonly_search_hook(MonoAssemblyName *aname, void *user_data) {
|
|
return GDMonoAssembly::_search_hook(aname, user_data, true);
|
|
}
|
|
|
|
MonoAssembly *GDMonoAssembly::assembly_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data) {
|
|
return GDMonoAssembly::_preload_hook(aname, assemblies_path, user_data, false);
|
|
}
|
|
|
|
MonoAssembly *GDMonoAssembly::assembly_refonly_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data) {
|
|
return GDMonoAssembly::_preload_hook(aname, assemblies_path, user_data, true);
|
|
}
|
|
|
|
MonoAssembly *GDMonoAssembly::_search_hook(MonoAssemblyName *aname, [[maybe_unused]] void *user_data, bool refonly) {
|
|
String name = String::utf8(mono_assembly_name_get_name(aname));
|
|
bool has_extension = name.ends_with(".dll") || name.ends_with(".exe");
|
|
|
|
GDMonoAssembly *loaded_asm = GDMono::get_singleton()->get_loaded_assembly(has_extension ? name.get_basename() : name);
|
|
if (loaded_asm) {
|
|
return loaded_asm->get_assembly();
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
MonoAssembly *GDMonoAssembly::_preload_hook(MonoAssemblyName *aname, char **, [[maybe_unused]] void *user_data, bool refonly) {
|
|
String name = String::utf8(mono_assembly_name_get_name(aname));
|
|
return _load_assembly_search(name, aname, refonly, search_dirs);
|
|
}
|
|
|
|
MonoAssembly *GDMonoAssembly::_load_assembly_search(const String &p_name, MonoAssemblyName *p_aname, bool p_refonly, const Vector<String> &p_search_dirs) {
|
|
MonoAssembly *res = nullptr;
|
|
String path;
|
|
|
|
bool has_extension = p_name.ends_with(".dll") || p_name.ends_with(".exe");
|
|
|
|
for (int i = 0; i < p_search_dirs.size(); i++) {
|
|
const String &search_dir = p_search_dirs[i];
|
|
|
|
if (has_extension) {
|
|
path = search_dir.plus_file(p_name);
|
|
if (FileAccess::exists(path)) {
|
|
res = _real_load_assembly_from(path, p_refonly, p_aname);
|
|
if (res != nullptr) {
|
|
return res;
|
|
}
|
|
}
|
|
} else {
|
|
path = search_dir.plus_file(p_name + ".dll");
|
|
if (FileAccess::exists(path)) {
|
|
res = _real_load_assembly_from(path, p_refonly, p_aname);
|
|
if (res != nullptr) {
|
|
return res;
|
|
}
|
|
}
|
|
|
|
path = search_dir.plus_file(p_name + ".exe");
|
|
if (FileAccess::exists(path)) {
|
|
res = _real_load_assembly_from(path, p_refonly, p_aname);
|
|
if (res != nullptr) {
|
|
return res;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
String GDMonoAssembly::find_assembly(const String &p_name) {
|
|
String path;
|
|
|
|
bool has_extension = p_name.ends_with(".dll") || p_name.ends_with(".exe");
|
|
|
|
for (int i = 0; i < search_dirs.size(); i++) {
|
|
const String &search_dir = search_dirs[i];
|
|
|
|
if (has_extension) {
|
|
path = search_dir.plus_file(p_name);
|
|
if (FileAccess::exists(path)) {
|
|
return path;
|
|
}
|
|
} else {
|
|
path = search_dir.plus_file(p_name + ".dll");
|
|
if (FileAccess::exists(path)) {
|
|
return path;
|
|
}
|
|
|
|
path = search_dir.plus_file(p_name + ".exe");
|
|
if (FileAccess::exists(path)) {
|
|
return path;
|
|
}
|
|
}
|
|
}
|
|
|
|
return String();
|
|
}
|
|
|
|
void GDMonoAssembly::initialize() {
|
|
fill_search_dirs(search_dirs);
|
|
|
|
mono_install_assembly_search_hook(&assembly_search_hook, nullptr);
|
|
mono_install_assembly_refonly_search_hook(&assembly_refonly_search_hook, nullptr);
|
|
mono_install_assembly_preload_hook(&assembly_preload_hook, nullptr);
|
|
mono_install_assembly_refonly_preload_hook(&assembly_refonly_preload_hook, nullptr);
|
|
mono_install_assembly_load_hook(&assembly_load_hook, nullptr);
|
|
}
|
|
|
|
MonoAssembly *GDMonoAssembly::_real_load_assembly_from(const String &p_path, bool p_refonly, MonoAssemblyName *p_aname) {
|
|
Vector<uint8_t> data = FileAccess::get_file_as_array(p_path);
|
|
ERR_FAIL_COND_V_MSG(data.is_empty(), nullptr, "Could read the assembly in the specified location");
|
|
|
|
String image_filename;
|
|
|
|
#ifdef ANDROID_ENABLED
|
|
if (p_path.begins_with("res://")) {
|
|
image_filename = p_path.substr(6, p_path.length());
|
|
} else {
|
|
image_filename = ProjectSettings::get_singleton()->globalize_path(p_path);
|
|
}
|
|
#else
|
|
// FIXME: globalize_path does not work on exported games
|
|
image_filename = ProjectSettings::get_singleton()->globalize_path(p_path);
|
|
#endif
|
|
|
|
MonoImageOpenStatus status = MONO_IMAGE_OK;
|
|
|
|
MonoImage *image = mono_image_open_from_data_with_name(
|
|
(char *)&data[0], data.size(),
|
|
true, &status, p_refonly,
|
|
image_filename.utf8());
|
|
|
|
ERR_FAIL_COND_V_MSG(status != MONO_IMAGE_OK || !image, nullptr, "Failed to open assembly image from memory: '" + p_path + "'.");
|
|
|
|
if (p_aname != nullptr) {
|
|
// Check assembly version
|
|
const MonoTableInfo *table = mono_image_get_table_info(image, MONO_TABLE_ASSEMBLY);
|
|
|
|
ERR_FAIL_NULL_V(table, nullptr);
|
|
|
|
if (mono_table_info_get_rows(table)) {
|
|
uint32_t cols[MONO_ASSEMBLY_SIZE];
|
|
mono_metadata_decode_row(table, 0, cols, MONO_ASSEMBLY_SIZE);
|
|
|
|
// Not sure about .NET's policy. We will only ensure major and minor are equal, and ignore build and revision.
|
|
uint16_t major = cols[MONO_ASSEMBLY_MAJOR_VERSION];
|
|
uint16_t minor = cols[MONO_ASSEMBLY_MINOR_VERSION];
|
|
|
|
uint16_t required_minor;
|
|
uint16_t required_major = mono_assembly_name_get_version(p_aname, &required_minor, nullptr, nullptr);
|
|
|
|
if (required_major != 0) {
|
|
if (major != required_major && minor != required_minor) {
|
|
mono_image_close(image);
|
|
return nullptr;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
Vector<uint8_t> pdb_data;
|
|
String pdb_path(p_path + ".pdb");
|
|
|
|
if (!FileAccess::exists(pdb_path)) {
|
|
pdb_path = p_path.get_basename() + ".pdb"; // without .dll
|
|
|
|
if (!FileAccess::exists(pdb_path)) {
|
|
goto no_pdb;
|
|
}
|
|
}
|
|
|
|
pdb_data = FileAccess::get_file_as_array(pdb_path);
|
|
|
|
// mono_debug_close_image doesn't seem to be needed
|
|
mono_debug_open_image_from_memory(image, &pdb_data[0], pdb_data.size());
|
|
|
|
no_pdb:
|
|
|
|
#endif
|
|
|
|
bool need_manual_load_hook = mono_image_get_assembly(image) != nullptr; // Re-using an existing image with an assembly loaded
|
|
|
|
status = MONO_IMAGE_OK;
|
|
|
|
MonoAssembly *assembly = mono_assembly_load_from_full(image, image_filename.utf8().get_data(), &status, p_refonly);
|
|
|
|
ERR_FAIL_COND_V_MSG(status != MONO_IMAGE_OK || !assembly, nullptr, "Failed to load assembly for image");
|
|
|
|
if (need_manual_load_hook) {
|
|
// For some reason if an assembly survived domain reloading (maybe because it's referenced somewhere else),
|
|
// the mono internal search hook don't detect it, yet mono_image_open_from_data_with_name re-uses the image
|
|
// and assembly, and mono_assembly_load_from_full doesn't call the load hook. We need to call it manually.
|
|
String name = String::utf8(mono_assembly_name_get_name(mono_assembly_get_name(assembly)));
|
|
bool has_extension = name.ends_with(".dll") || name.ends_with(".exe");
|
|
GDMonoAssembly *loaded_asm = GDMono::get_singleton()->get_loaded_assembly(has_extension ? name.get_basename() : name);
|
|
if (!loaded_asm) {
|
|
assembly_load_hook(assembly, nullptr);
|
|
}
|
|
}
|
|
|
|
// Decrement refcount which was previously incremented by mono_image_open_from_data_with_name
|
|
mono_image_close(image);
|
|
|
|
return assembly;
|
|
}
|
|
|
|
void GDMonoAssembly::unload() {
|
|
ERR_FAIL_NULL(image); // Should not be called if already unloaded
|
|
|
|
for (Map<MonoClass *, GDMonoClass *>::Element *E = cached_raw.front(); E; E = E->next()) {
|
|
memdelete(E->value());
|
|
}
|
|
|
|
cached_classes.clear();
|
|
cached_raw.clear();
|
|
|
|
assembly = nullptr;
|
|
image = nullptr;
|
|
}
|
|
|
|
String GDMonoAssembly::get_path() const {
|
|
return String::utf8(mono_image_get_filename(image));
|
|
}
|
|
|
|
bool GDMonoAssembly::has_attribute(GDMonoClass *p_attr_class) {
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_NULL_V(p_attr_class, false);
|
|
#endif
|
|
|
|
if (!attrs_fetched) {
|
|
fetch_attributes();
|
|
}
|
|
|
|
if (!attributes) {
|
|
return false;
|
|
}
|
|
|
|
return mono_custom_attrs_has_attr(attributes, p_attr_class->get_mono_ptr());
|
|
}
|
|
|
|
MonoObject *GDMonoAssembly::get_attribute(GDMonoClass *p_attr_class) {
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_NULL_V(p_attr_class, nullptr);
|
|
#endif
|
|
|
|
if (!attrs_fetched) {
|
|
fetch_attributes();
|
|
}
|
|
|
|
if (!attributes) {
|
|
return nullptr;
|
|
}
|
|
|
|
return mono_custom_attrs_get_attr(attributes, p_attr_class->get_mono_ptr());
|
|
}
|
|
|
|
void GDMonoAssembly::fetch_attributes() {
|
|
ERR_FAIL_COND(attributes != nullptr);
|
|
|
|
attributes = mono_custom_attrs_from_assembly(assembly);
|
|
attrs_fetched = true;
|
|
}
|
|
|
|
GDMonoClass *GDMonoAssembly::get_class(const StringName &p_namespace, const StringName &p_name) {
|
|
ERR_FAIL_NULL_V(image, nullptr);
|
|
|
|
ClassKey key(p_namespace, p_name);
|
|
|
|
GDMonoClass **match = cached_classes.getptr(key);
|
|
|
|
if (match) {
|
|
return *match;
|
|
}
|
|
|
|
MonoClass *mono_class = mono_class_from_name(image, String(p_namespace).utf8(), String(p_name).utf8());
|
|
|
|
if (!mono_class) {
|
|
return nullptr;
|
|
}
|
|
|
|
GDMonoClass *wrapped_class = memnew(GDMonoClass(p_namespace, p_name, mono_class, this));
|
|
|
|
cached_classes[key] = wrapped_class;
|
|
cached_raw[mono_class] = wrapped_class;
|
|
|
|
return wrapped_class;
|
|
}
|
|
|
|
GDMonoClass *GDMonoAssembly::get_class(MonoClass *p_mono_class) {
|
|
ERR_FAIL_NULL_V(image, nullptr);
|
|
|
|
Map<MonoClass *, GDMonoClass *>::Element *match = cached_raw.find(p_mono_class);
|
|
|
|
if (match) {
|
|
return match->value();
|
|
}
|
|
|
|
StringName namespace_name = String::utf8(mono_class_get_namespace(p_mono_class));
|
|
StringName class_name = String::utf8(mono_class_get_name(p_mono_class));
|
|
|
|
GDMonoClass *wrapped_class = memnew(GDMonoClass(namespace_name, class_name, p_mono_class, this));
|
|
|
|
cached_classes[ClassKey(namespace_name, class_name)] = wrapped_class;
|
|
cached_raw[p_mono_class] = wrapped_class;
|
|
|
|
return wrapped_class;
|
|
}
|
|
|
|
GDMonoAssembly *GDMonoAssembly::load(const String &p_name, MonoAssemblyName *p_aname, bool p_refonly, const Vector<String> &p_search_dirs) {
|
|
if (GDMono::get_singleton()->get_corlib_assembly() && (p_name == "mscorlib" || p_name == "mscorlib.dll")) {
|
|
return GDMono::get_singleton()->get_corlib_assembly();
|
|
}
|
|
|
|
// We need to manually call the search hook in this case, as it won't be called in the next step
|
|
MonoAssembly *assembly = mono_assembly_invoke_search_hook(p_aname);
|
|
|
|
if (!assembly) {
|
|
assembly = _load_assembly_search(p_name, p_aname, p_refonly, p_search_dirs);
|
|
if (!assembly) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
GDMonoAssembly *loaded_asm = GDMono::get_singleton()->get_loaded_assembly(p_name);
|
|
ERR_FAIL_NULL_V_MSG(loaded_asm, nullptr, "Loaded assembly missing from table. Did we not receive the load hook?");
|
|
ERR_FAIL_COND_V(loaded_asm->get_assembly() != assembly, nullptr);
|
|
|
|
return loaded_asm;
|
|
}
|
|
|
|
GDMonoAssembly *GDMonoAssembly::load_from(const String &p_name, const String &p_path, bool p_refonly) {
|
|
if (p_name == "mscorlib" || p_name == "mscorlib.dll") {
|
|
return GDMono::get_singleton()->get_corlib_assembly();
|
|
}
|
|
|
|
// We need to manually call the search hook in this case, as it won't be called in the next step
|
|
MonoAssemblyName *aname = mono_assembly_name_new(p_name.utf8());
|
|
MonoAssembly *assembly = mono_assembly_invoke_search_hook(aname);
|
|
mono_assembly_name_free(aname);
|
|
mono_free(aname);
|
|
|
|
if (!assembly) {
|
|
assembly = _real_load_assembly_from(p_path, p_refonly);
|
|
if (!assembly) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
GDMonoAssembly *loaded_asm = GDMono::get_singleton()->get_loaded_assembly(p_name);
|
|
ERR_FAIL_NULL_V_MSG(loaded_asm, nullptr, "Loaded assembly missing from table. Did we not receive the load hook?");
|
|
|
|
return loaded_asm;
|
|
}
|
|
|
|
GDMonoAssembly::~GDMonoAssembly() {
|
|
if (image) {
|
|
unload();
|
|
}
|
|
}
|