Timerix/ougge
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Class::getMethod

Browse Source
This commit is contained in:
Timerix 2024-08-22 08:36:01 +05:00
parent 478e6049c9
commit 71eea1c0fe
7 changed files with 208 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/Mono/Assembly.cpp Normal file
View File

@ -0,0 +1,23 @@
#include "Mono.hpp"
namespace Mono {
Assembly::Assembly(MonoAssembly *ptr)
: ptr(ptr), image(mono_assembly_get_image(ptr))
{
}
Assembly::~Assembly(){
// Tt causes SEGFAULT.
// Is it even possible to unload assembly from domain?
// mono_assembly_close(ptr);
}
std::shared_ptr<Class> Assembly::getClass(const std::string &name_space, const std::string &name){
MonoClass* ptr = mono_class_from_name(image, name_space.c_str(), name.c_str());
if(!ptr)
throw UsefulException(format("can't find class '%s.%s'", name_space.c_str(), name.c_str()));
return std::make_shared<Class>(ptr, name_space, name);
}
}

33
src/Mono/Class.cpp Normal file
View File

@ -0,0 +1,33 @@
#include "Mono.hpp"
namespace Mono {
Class::Class(MonoClass *ptr, const std::string& name_space, const std::string& name)
: ptr(ptr), name_space(name_space), name(name)
{
void* iter = nullptr;
MonoMethod* m = nullptr;
while( (m = mono_class_get_methods(ptr, &iter)) ){
auto name = std::string_view(mono_method_get_name(m));
methods.emplace(std::piecewise_construct,
std::forward_as_tuple(name),
std::forward_as_tuple(m, name));
}
}
template<>
void* _valueToVoidPtr<Object>(Object& v){ return v; }
template<>
void* _valueToVoidPtr<String>(String& v){ return v; }
template<>
Object _valueFromMonoObject<Object>(MonoObject* o){
return (Object)o;
}
template<>
String _valueFromMonoObject<String>(MonoObject* o){
return (String)((void*)o);
}
}

16
src/Mono/Method.cpp Normal file
View File

@ -0,0 +1,16 @@
#include "Mono.hpp"
namespace Mono {
Method::Method(MonoMethod *ptr, const std::string_view& name)
: ptr(ptr), signature(mono_method_signature(ptr)), name(name)
{
void* iter = nullptr;
return_type = mono_signature_get_return_type(signature);
MonoType* pt = nullptr;
while( (pt = mono_signature_get_params(signature, &iter)) ){
argument_types.push_back(pt);
}
}
}

90
src/Mono/Mono.cpp
View File

@ -1,80 +1,22 @@
#include "Mono.hpp"
#include "../UsefulException.hpp"
#include "../format.hpp"
#include <mono/jit/jit.h>
#include <mono/metadata/mono-config.h>
#include <mono/metadata/debug-helpers.h>
#include <iostream>
#include <mono/metadata/appdomain.h>
namespace Mono {
RuntimeJIT::RuntimeJIT(const std::string& domain_name){
mono_set_dirs("mono-libs", "mono-libs");
mono_set_assemblies_path("mono-libs");
mono_config_parse("mono-libs/config.xml");
template <> MonoClass* getClass<SByte>(){ return mono_get_sbyte_class(); }
template <> MonoClass* getClass<Byte>(){ return mono_get_byte_class(); }
template <> MonoClass* getClass<Short>(){ return mono_get_int16_class(); }
template <> MonoClass* getClass<UShort>(){ return mono_get_uint16_class(); }
template <> MonoClass* getClass<Int>(){ return mono_get_int32_class(); }
template <> MonoClass* getClass<UInt>(){ return mono_get_uint32_class(); }
template <> MonoClass* getClass<Long>(){ return mono_get_int64_class(); }
template <> MonoClass* getClass<ULong>(){ return mono_get_uint64_class(); }
template <> MonoClass* getClass<Float>(){ return mono_get_single_class(); }
template <> MonoClass* getClass<Double>(){ return mono_get_double_class(); }
template <> MonoClass* getClass<Bool>(){ return mono_get_boolean_class(); }
template <> MonoClass* getClass<Char>(){ return mono_get_char_class(); }
template <> MonoClass* getClass<String>(){ return mono_get_string_class(); }
template <> MonoClass* getClass<Object>(){ return mono_get_object_class(); }
template <> MonoClass* getClass<Void>(){ return mono_get_void_class(); }
domain = mono_jit_init(domain_name.c_str());
if(!domain)
throw UsefulException("can't initialize mono domain");
}
RuntimeJIT::~RuntimeJIT(){
mono_jit_cleanup(domain);
}
std::shared_ptr<Assembly> RuntimeJIT::loadAssembly(const std::string &name){
MonoAssembly* ptr = mono_domain_assembly_open(domain, "app.exe");
if(!ptr)
throw UsefulException(format("can't load assembly '%s'", name.c_str()));
return std::make_shared<Assembly>(ptr);
}
Assembly::Assembly(MonoAssembly *ptr)
: ptr(ptr), image(mono_assembly_get_image(ptr))
{
}
Assembly::~Assembly(){
// Tt causes SEGFAULT.
// Is it even possible to unload assembly from domain?
// mono_assembly_close(ptr);
}
std::shared_ptr<Class> Assembly::getClass(const std::string &name_space, const std::string &name){
MonoClass* ptr = mono_class_from_name(image, name_space.c_str(), name.c_str());
if(!ptr)
throw UsefulException(format("can't find class '%s.%s'", name_space.c_str(), name.c_str()));
return std::make_shared<Class>(ptr);
}
Class::Class(MonoClass *ptr)
: ptr(ptr)
{
void* iter = nullptr;
MonoMethod* m = nullptr;
while( (m = mono_class_get_methods(ptr, &iter)) ){
auto name = std::string_view(mono_method_get_name(m));
methods.emplace(std::piecewise_construct,
std::forward_as_tuple(name),
std::forward_as_tuple(name, m));
}
}
template<typename ReturnT, typename... ArgTypes>
std::shared_ptr<std::function<ReturnT(ArgTypes...)>> getMethod(const std::string& name){
return std::make_shared<std::function<ReturnT(ArgTypes...)>>();
}
Method::Method(const std::string_view &name, MonoMethod *ptr)
: ptr(ptr), signature(mono_method_signature(ptr)), name(name)
{
void* iter = nullptr;
MonoType* rt = mono_signature_get_return_type(signature);
MonoType* pt = nullptr;
while( (pt = mono_signature_get_params(signature, &iter)) ){
std::cout<<"name: "<<mono_type_get_name(pt)<<std::endl;
}
}
} // namespace Mono

93
src/Mono/Mono.hpp
View File

@ -1,5 +1,7 @@
#pragma once
#include "../std.hpp"
#include "../UsefulException.hpp"
#include "../format.hpp"
#include <memory>
#include <string>
#include <functional>
@ -16,34 +18,105 @@ typedef u8 Byte;
typedef i16 Short;
typedef u16 UShort;
typedef i32 Int;
typedef i32 UInt;
typedef u32 UInt;
typedef i64 Long;
typedef i64 ULong;
typedef u64 ULong;
typedef f32 Float;
typedef f64 Double;
typedef union { mono_bool wide_bool; } Bool; //USAGE: Bool t = {true};
typedef char16_t Char;
typedef MonoString* String;
typedef MonoObject* Object;
typedef void Void;
template<typename PrimitiveT>
MonoClass* getClass();
class Method {
public:
MonoMethod* ptr;
MonoMethodSignature* signature;
public:
const std::string_view name;
Method(const std::string_view& name, MonoMethod* ptr);
MonoType* return_type;
std::vector<MonoType*> argument_types;
Method(MonoMethod* ptr, const std::string_view& name);
};
template<typename T>
void* _valueToVoidPtr(T& v){
return &v;
}
template<typename T>
T _valueFromMonoObject(MonoObject* o){
void* result_value_ptr = mono_object_unbox(o);
if(result_value_ptr == nullptr)
throw UsefulException("can't unbox method value");
return *((T*)result_value_ptr);
}
class Class {
std::multimap<std::string_view, Method> methods;
MonoClass* ptr;
public:
Class(MonoClass* ptr);
std::multimap<std::string_view, Method> methods;
MonoClass* ptr;
const std::string name_space;
const std::string name;
Class(MonoClass* ptr, const std::string& name_space, const std::string& name);
Class(const Class&) = delete;
/// @brief all types must have template implementation of getClass<T>()
/// @tparam ReturnT return type
/// @tparam ...ArgTypes argument types
/// @return function which takes arguments and returns value of ReturnT
template<typename ReturnT, typename... ArgTypes>
std::shared_ptr<std::function<ReturnT(ArgTypes...)>> getMethod(const std::string& name);
std::shared_ptr<std::function<ReturnT(MonoObject*, ArgTypes...)>> getMethod(const std::string& name){
Method* m = nullptr;
static std::vector<MonoClass*> arg_classes { getClass<ArgTypes>()... };
// iterate each method overload
for(auto it = methods.find(name); it != methods.end(); it++){
m = &it->second;
// compare argument count
if(m->argument_types.size() != arg_classes.size())
continue;
// compare return type
if(!mono_metadata_type_equal(m->return_type, mono_class_get_type(getClass<ReturnT>())))
continue;
// compare argument types
bool argument_types_mismatch = false;
for(size_t i = 0; i < arg_classes.size(); i++){
if(!mono_metadata_type_equal(m->argument_types[i], mono_class_get_type(arg_classes[i]))){
argument_types_mismatch = true;
break;
}
}
if(argument_types_mismatch)
continue;
// passed all tests successfully
break;
}
// if method not found throw exception
if(m == nullptr)
throw UsefulException(format("can't get method '%s' from class '%s'",
name.c_str(), this->name.c_str()));
MonoMethod* m_ptr = m->ptr;
return std::make_shared<std::function<ReturnT(MonoObject*, ArgTypes...)>>(
[m_ptr](MonoObject* class_instance, ArgTypes... args) -> ReturnT
{
void* arg_array[] = { _valueToVoidPtr(args)..., nullptr };
// MonoException* ex = nullptr;
// TODO: exception catch
MonoObject* result = mono_runtime_invoke(m_ptr, class_instance, arg_array, nullptr);
return _valueFromMonoObject<ReturnT>(result);
}
);
}
};
class Assembly {
MonoAssembly* ptr;
MonoImage* image;
@ -69,4 +142,4 @@ public:
std::shared_ptr<Assembly> loadAssembly(const std::string& name);
};
}
} // namespace Mono

28
src/Mono/Runtime.cpp Normal file
View File

@ -0,0 +1,28 @@
#include "Mono.hpp"
#include <mono/jit/jit.h>
#include <mono/metadata/mono-config.h>
namespace Mono {
RuntimeJIT::RuntimeJIT(const std::string& domain_name){
mono_set_dirs("mono-libs", "mono-libs");
mono_set_assemblies_path("mono-libs");
mono_config_parse("mono-libs/config.xml");
domain = mono_jit_init(domain_name.c_str());
if(!domain)
throw UsefulException("can't initialize mono domain");
}
RuntimeJIT::~RuntimeJIT(){
mono_jit_cleanup(domain);
}
std::shared_ptr<Assembly> RuntimeJIT::loadAssembly(const std::string &name){
MonoAssembly* ptr = mono_domain_assembly_open(domain, "app.exe");
if(!ptr)
throw UsefulException(format("can't load assembly '%s'", name.c_str()));
return std::make_shared<Assembly>(ptr);
}
}

11
src/main.cpp
View File

@ -15,12 +15,19 @@ void update(f64 deltaTime){
int main(int argc, const char** argv){
try {
Resources::init();
std::cout<<"initialized resource loader"<<std::endl;
// Resources::init();
// std::cout<<"initialized resource loader"<<std::endl;
Mono::RuntimeJIT mono;
auto a = mono.loadAssembly("app.exe");
auto c = a->getClass("", "A");
auto m = c->getMethod<Mono::Int, Mono::Byte, Mono::Float>("Method");
std::cout<<"method has been found"<<std::endl;
Mono::Int r = m->operator()(nullptr, 16, 0.32);
std::cout<<"result: "<<r<<std::endl;
return 0;
std::cout<<"initialized mono jit runtime"<<std::endl;
GUI::MainWindow w;
w.open("ougge", update);
std::cout<<"created sdl window"<<std::endl;