#include "module.hpp"

#include <array>

#include <climits>

#include <cuchar>

#include <bitset>

#include <exception>

#include <plg/string.hpp>

#include <plg/any.hpp>

#include <plg/format.hpp>

#include <plugify/enum_object.hpp>

#include <plugify/enum_value.hpp>

#include <plugify/alias.hpp>

#include <plugify/binding.hpp>

#define LOG_PREFIX "[PY3LM] "

using namespace plugify;

namespace fs = std::filesystem;

namespace py3lm {

extern Python3LanguageModule g_py3lm;

namespace {

void ReplaceAll(std::string& str, const std::string& from, const std::string& to) {

size_t start_pos{};

while ((start_pos = str.find(from, start_pos)) != std::string::npos) {

str.replace(start_pos, from.length(), to);

start_pos += to.length();

}

}

std::string_view PyUnicode_AsString(PyObject* object) {

Py_ssize_t size{};

const char *buffer = PyUnicode_AsUTF8AndSize(object, &size);

if (buffer) {

return { buffer, static_cast<size_t>(size) };

}

return {};

}

int IsEmptyModule(PyObject* module) {

if (!module || !PyModule_Check(module)) {

return -1;

}

PyObject* const moduleDict = PyModule_GetDict(module);

if (!moduleDict || !PyDict_Check(moduleDict)) {

return -1;

}

using namespace std::literals::string_view_literals;

constexpr std::array defaultAttrs = {

"__name__"sv, "__doc__"sv, "__package__"sv, "__loader__"sv, "__spec__"sv, "__file__"sv, "__cached__"sv

};

PyObject *key, *value;

Py_ssize_t pos = 0;

while (PyDict_Next(moduleDict, &pos, &key, &value)) {

std::string_view attribute = PyUnicode_AsString(key);

if (!std::any_of(defaultAttrs.begin(), defaultAttrs.end(),

[&attribute](const std::string_view& attr) {

return attribute == attr;

})) {

return 0; // Not empty

}

}

return 1; // Empty

}

bool IsStaticMethod(PyObject* object) {

if (PyCFunction_Check(object)) {

PyCFunctionObject* const cfunc = reinterpret_cast<PyCFunctionObject*>(object);

if (cfunc->m_ml && (cfunc->m_ml->ml_flags & METH_STATIC)) {

return true;

}

}

return false;

}

// Return codes:

// [1, 3] Number bytes used

// 0 Sequence starts with \0

// -1 Encoding error

// -2 Invalid multibyte sequence

// -3 Surrogate pair

std::pair<int, char16_t> ConvertUtf8ToUtf16(std::string_view sequence) {

const auto c8toc16 = [](char ch) -> char16_t { return static_cast<char16_t>(static_cast<uint8_t>(ch)); };

if (sequence.empty()) {

return { -2, u'\0' };

}

const char seqCh0 = sequence[0];

if (seqCh0 == '\0') {

return { 0, u'\0' };

}

if ((seqCh0 & 0b11111000) == 0b11110000) {

return { -3, u'\0' };

}

if ((seqCh0 & 0b11110000) == 0b11100000) {

if (sequence.size() < 3) {

return { -2, u'\0' };

}

const char seqCh1 = sequence[1];

const char seqCh2 = sequence[2];

if ((seqCh1 & 0b11000000) != 0b10000000 || (seqCh2 & 0b11000000) != 0b10000000) {

return { -2, u'\0' };

}

const char16_t ch = static_cast<char16_t>((c8toc16(seqCh0 & 0b00001111) << 12) | (c8toc16(seqCh1 & 0b00111111) << 6) | c8toc16(seqCh2 & 0b00111111));

if (0xD800 <= static_cast<uint16_t>(ch) && static_cast<uint16_t>(ch) < 0xE000) {

return { -1, u'\0' };

}

return { 3, ch };

}

if ((seqCh0 & 0b11100000) == 0b11000000) {

if (sequence.size() < 2) {

return { -2, u'\0' };

}

const char seqCh1 = sequence[1];

if ((seqCh1 & 0b11000000) != 0b10000000) {

return { -2, u'\0' };

}

const char16_t ch = static_cast<uint16_t>((c8toc16(seqCh0 & 0b00011111) << 6) | c8toc16(seqCh1 & 0b00111111));

return { 2, ch };

}

if ((seqCh0 & 0b10000000) == 0b00000000) {

return { 1, c8toc16(seqCh0) };

}

return { -1, u'\0' };

}

// Return codes:

// [1, 3] Number bytes returned

// 0 For 0x0000 symbol

// -1 Surrogate pair

std::pair<int, std::array<char, 4>> ConvertUtf16ToUtf8(char16_t ch16) {

const auto c16toc8 = [](char16_t ch) -> char { return static_cast<char>(static_cast<uint8_t>(ch)); };

if (ch16 == u'\0') {

return { 0, {} };

}

if (static_cast<uint16_t>(ch16) < 0x80) {

return { 1, { c16toc8(ch16), '\0' } };

}

if (static_cast<uint16_t>(ch16) < 0x800) {

return { 2, { c16toc8(((ch16 & 0b11111000000) >> 6) | 0b11000000), c16toc8((ch16 & 0b111111) | 0b10000000), '\0' } };

}

if (0xD800 <= static_cast<uint16_t>(ch16) && static_cast<uint16_t>(ch16) < 0xE000) {

return { -1, {} };

}

return { 3, { c16toc8(((ch16 & 0b1111000000000000) >> 12) | 0b11100000), c16toc8(((ch16 & 0b111111000000) >> 6) | 0b10000000), c16toc8((ch16 & 0b111111) | 0b10000000), '\0' } };

}

// Generic function to check if value is in range of type N

template<typename T, typename U = T>

bool IsInRange(T value) {

if constexpr (std::is_same_v<U, T>) {

return true;

} else if constexpr (std::is_floating_point_v<T> && std::is_floating_point_v<U>) {

// Handle floating-point range checks

return value >= static_cast<T>(-std::numeric_limits<U>::infinity()) &&

value <= static_cast<T>(std::numeric_limits<U>::infinity());

} else if constexpr (std::is_signed_v<T> == std::is_signed_v<U>) {

// Both T and N are signed or unsigned

return value >= static_cast<T>(std::numeric_limits<U>::min()) &&

value <= static_cast<T>(std::numeric_limits<U>::max());

} else if constexpr (std::is_unsigned_v<T> && std::is_signed_v<U>) {

// T is unsigned, N is signed

if (value > static_cast<T>(std::numeric_limits<U>::max())) {

return false;

}

return true;

} else if constexpr (std::is_signed_v<T> && std::is_unsigned_v<U>) {

// T is signed, N is unsigned

if (value < 0 || static_cast<std::make_unsigned_t<T>>(value) > std::numeric_limits<U>::max()) {

return false;

}

return true;

}

}

// Function to find the index of the flipped bit

template<size_t N>

constexpr size_t FindBitSetIndex(const std::bitset<N>& bitset) {

for (size_t i = 0; i < bitset.size(); ++i) {

if (bitset[i])

return i;

}

return static_cast<size_t>(-1);

}

template<class T>

constexpr bool always_false_v = std::is_same_v<std::decay_t<T>, std::add_cv_t<std::decay_t<T>>>;

template<class T>

constexpr bool is_vector_type_v =

std::is_same_v<T, plg::vector<bool>> ||

std::is_same_v<T, plg::vector<char>> ||

std::is_same_v<T, plg::vector<char16_t>> ||

std::is_same_v<T, plg::vector<int8_t>> ||

std::is_same_v<T, plg::vector<int16_t>> ||

std::is_same_v<T, plg::vector<int32_t>> ||

std::is_same_v<T, plg::vector<int64_t>> ||

std::is_same_v<T, plg::vector<uint8_t>> ||

std::is_same_v<T, plg::vector<uint16_t>> ||

std::is_same_v<T, plg::vector<uint32_t>> ||

std::is_same_v<T, plg::vector<uint64_t>> ||

std::is_same_v<T, plg::vector<void*>> ||

std::is_same_v<T, plg::vector<float>> ||

std::is_same_v<T, plg::vector<double>> ||

std::is_same_v<T, plg::vector<plg::string>> ||

std::is_same_v<T, plg::vector<plg::variant<plg::none>>> ||

std::is_same_v<T, plg::vector<plg::vec2>> ||

std::is_same_v<T, plg::vector<plg::vec3>> ||

std::is_same_v<T, plg::vector<plg::vec4>> ||

std::is_same_v<T, plg::vector<plg::mat4x4>>;

template<class T>

constexpr bool is_none_type_v =

std::is_same_v<T, plg::invalid> ||

std::is_same_v<T, plg::none> ||

std::is_same_v<T, plg::variant<plg::none>> ||

std::is_same_v<T, plg::function> ||

std::is_same_v<T, plg::any>;

void SetTypeError(std::string_view message, PyObject* object) {

const std::string error(std::format("{}, but {} provided", message, g_py3lm.GetObjectType(object).name));

PyErr_SetString(PyExc_TypeError, error.c_str());

}

template<typename T>

std::optional<T> ValueFromObject([[maybe_unused]] PyObject* object) {

static_assert(always_false_v<T>, "ValueFromObject specialization required");

}

template<>

std::optional<bool> ValueFromObject(PyObject* object) {

if (PyBool_Check(object)) {

return object == Py_True;

}

SetTypeError("Expected boolean", object);

return std::nullopt;

}

template<>

std::optional<char> ValueFromObject(PyObject* object) {

if (PyUnicode_Check(object)) {

const Py_ssize_t length = PyUnicode_GetLength(object);

if (length == 0) {

return '\0';

}

if (length == 1) {

char ch = PyUnicode_AsUTF8(object)[0];

if ((ch & 0x80) == 0) {

return ch;

}

// Can't pass multibyte character

PyErr_SetString(PyExc_ValueError, "Multibyte character");

}

else {

PyErr_SetString(PyExc_ValueError, "Length bigger than 1");

}

return std::nullopt;

}

SetTypeError("Expected string", object);

return std::nullopt;

}

template<>

std::optional<char16_t> ValueFromObject(PyObject* object) {

if (PyUnicode_Check(object)) {

const Py_ssize_t length = PyUnicode_GetLength(object);

if (length == 0) {

return u'\0';

}

if (length == 1) {

auto [rc, ch] = ConvertUtf8ToUtf16(PyUnicode_AsString(object));

switch (rc) {

case 0:

case 1:

case 2:

case 3:

return ch;

case -3:

PyErr_SetString(PyExc_ValueError, "Surrogate pair");

break;

case -2:

PyErr_SetString(PyExc_ValueError, "Invalid multibyte character");

break;

case -1:

PyErr_SetString(PyExc_RuntimeError, "Encoding error");

break;

}

}

else {

PyErr_SetString(PyExc_ValueError, "Length bigger than 1");

}

return std::nullopt;

}

SetTypeError("Expected string", object);

return std::nullopt;

}

template<typename T>

std::optional<T> GetObjectAttrAsValue(PyObject* object, const char* attr_name);

template<class ValueType, class CType, CType (*ConvertFunc)(PyObject*)> requires(std::is_signed_v<ValueType> || std::is_unsigned_v<ValueType>)

std::optional<ValueType> ValueFromNumberObject(PyObject* object) {

// int or IntEnum

if (PyLong_Check(object)) {

const CType castResult = ConvertFunc(object);

if (!PyErr_Occurred()) {

if (IsInRange<CType, ValueType>(castResult)) {

return static_cast<ValueType>(castResult);

}

PyErr_SetNone(PyExc_OverflowError);

}

return std::nullopt;

}

// Enum

else if (PyObject_TypeCheck(object, &PyEnum_Type)) {

PyObject* value = PyObject_GetAttrString(object, "value");

if (value) {

if (PyLong_Check(value)) {

const CType castResult = ConvertFunc(value);

if (!PyErr_Occurred()) {

if (IsInRange<CType, ValueType>(castResult)) {

Py_DECREF(value);

return static_cast<ValueType>(castResult);

}

PyErr_SetNone(PyExc_OverflowError);

}

}

Py_DECREF(value);

} else {

PyErr_Clear();

SetTypeError("Expected enum with 'value' attribute", object);

}

return std::nullopt;

}

SetTypeError("Expected integer", object);

return std::nullopt;

}

template<class ValueType> requires(std::is_floating_point_v<ValueType>)

std::optional<ValueType> ValueFromFloatObject(PyObject* object) {

if (PyFloat_Check(object)) {

const double castResult = PyFloat_AS_DOUBLE(object);

if (!PyErr_Occurred()) {

if (IsInRange<double, ValueType>(castResult)) {

return static_cast<ValueType>(castResult);

}

PyErr_SetNone(PyExc_OverflowError);

}

return std::nullopt;

}

SetTypeError("Expected float", object);

return std::nullopt;

}

template<class ValueType, auto ConvertFunc>

auto ValueFromNumberObject(PyObject* object) {

return ValueFromNumberObject<ValueType, std::invoke_result_t<decltype(ConvertFunc), PyObject*>, ConvertFunc>(object);

}

template<>

std::optional<int8_t> ValueFromObject(PyObject* object) {

return ValueFromNumberObject<int8_t, PyLong_AsLong>(object);

}

template<>

std::optional<int16_t> ValueFromObject(PyObject* object) {

return ValueFromNumberObject<int16_t, PyLong_AsLong>(object);

}

template<>

std::optional<int32_t> ValueFromObject(PyObject* object) {

return ValueFromNumberObject<int32_t, PyLong_AsLong>(object);

}

template<>

std::optional<int64_t> ValueFromObject(PyObject* object) {

return ValueFromNumberObject<int64_t, PyLong_AsLongLong>(object);

}

template<>

std::optional<uint8_t> ValueFromObject(PyObject* object) {

return ValueFromNumberObject<uint8_t, PyLong_AsUnsignedLong>(object);

}

template<>

std::optional<uint16_t> ValueFromObject(PyObject* object) {

return ValueFromNumberObject<uint16_t, PyLong_AsUnsignedLong>(object);

}

template<>

std::optional<uint32_t> ValueFromObject(PyObject* object) {

return ValueFromNumberObject<uint32_t, PyLong_AsUnsignedLong>(object);

}

template<>

std::optional<uint64_t> ValueFromObject(PyObject* object) {

return ValueFromNumberObject<uint64_t, PyLong_AsUnsignedLongLong>(object);

}

template<>

std::optional<void*> ValueFromObject(PyObject* object) {

if (PyLong_Check(object)) {

const auto result = PyLong_AsVoidPtr(object);

if (!PyErr_Occurred()) {

return result;

}

}

SetTypeError("Expected integer", object);

return std::nullopt;

}

template<>

std::optional<float> ValueFromObject(PyObject* object) {

return ValueFromFloatObject<float>(object);

}

template<>

std::optional<double> ValueFromObject(PyObject* object) {

return ValueFromFloatObject<double>(object);

}

template<>

std::optional<plg::string> ValueFromObject(PyObject* object) {

if (PyUnicode_Check(object)) {

return PyUnicode_AsString(object);

}

SetTypeError("Expected string", object);

return std::nullopt;

}

template<typename T>

std::optional<plg::vector<T>> ArrayFromObject(PyObject* arrayObject);

template<>

std::optional<plg::any> ValueFromObject(PyObject* object) {

auto [type, name] = g_py3lm.GetObjectType(object);

switch (type) {

case PyAbstractType::Long:

return static_cast<int64_t>(PyLong_AsLongLong(object));

case PyAbstractType::Bool:

return PyLong_AsLong(object) != 0;

case PyAbstractType::Float:

return PyFloat_AS_DOUBLE(object);

case PyAbstractType::Unicode: {

return PyUnicode_AsString(object);

}

case PyAbstractType::List: {

const Py_ssize_t size = PyList_Size(object);

if (size == 0) {

return plg::vector<int64_t>();

}

std::bitset<MaxPyTypes> flags;

for (Py_ssize_t i = 0; i < size; i++) {

PyObject* const valueObject = PyList_GetItem(object, i);

if (valueObject) {

auto [valueType, _] = g_py3lm.GetObjectType(valueObject);

if (valueType != PyAbstractType::Invalid) {

flags.set(static_cast<size_t>(valueType));

}

continue;

}

return std::nullopt;

}

if (flags.count() == 1) {

const auto flag = static_cast<PyAbstractType>(FindBitSetIndex(flags));

switch (flag) {

case PyAbstractType::Long: {

if (auto array = ArrayFromObject<int64_t>(object)) {

return std::move(*array);

}

return std::nullopt;

}

case PyAbstractType::Bool: {

if (auto array = ArrayFromObject<bool>(object)) {

return std::move(*array);

}

return std::nullopt;

}

case PyAbstractType::Float: {

if (auto array = ArrayFromObject<double>(object)) {

return std::move(*array);

}

return std::nullopt;

}

case PyAbstractType::Unicode: {

if (auto array = ArrayFromObject<plg::string>(object)) {

return std::move(*array);

}

return std::nullopt;

}

case PyAbstractType::Vector2: {

if (auto array = ArrayFromObject<plg::vec2>(object)) {

return std::move(*array);

}

return std::nullopt;

}

case PyAbstractType::Vector3: {

if (auto array = ArrayFromObject<plg::vec3>(object)) {

return std::move(*array);

}

return std::nullopt;

}

case PyAbstractType::Vector4: {

if (auto array = ArrayFromObject<plg::vec4>(object)) {

return std::move(*array);

}

return std::nullopt;

}

case PyAbstractType::Matrix4x4: {

if (auto array = ArrayFromObject<plg::mat4x4>(object)) {

return std::move(*array);

}

return std::nullopt;

}

default:

break;

}

}

std::string error("List should contains supported types, but contains: [");

bool first = true;

for (Py_ssize_t i = 0; i < size; i++) {

PyObject* const valueObject = PyList_GetItem(object, i);

auto [_, valueName] = g_py3lm.GetObjectType(valueObject);

if (first) {

std::format_to(std::back_inserter(error), "'{}", valueName);

first = false;

} else {

std::format_to(std::back_inserter(error), "', '{}", valueName);

}

}

error += "']";

PyErr_SetString(PyExc_TypeError, error.c_str());

return std::nullopt;

}

case PyAbstractType::Vector2:

return g_py3lm.Vector2ValueFromObject(object);

case PyAbstractType::Vector3:

return g_py3lm.Vector3ValueFromObject(object);

case PyAbstractType::Vector4:

return g_py3lm.Vector4ValueFromObject(object);

default:

const std::string error(std::format("Any argument not supports python type: {} for marshalling.", name));

PyErr_SetString(PyExc_TypeError, error.c_str());

return std::nullopt;

}

}

template<>

std::optional<plg::vec2> ValueFromObject(PyObject* object) {

return g_py3lm.Vector2ValueFromObject(object);

}

template<>

std::optional<plg::vec3> ValueFromObject(PyObject* object) {

return g_py3lm.Vector3ValueFromObject(object);

}

template<>

std::optional<plg::vec4> ValueFromObject(PyObject* object) {

return g_py3lm.Vector4ValueFromObject(object);

}

template<>

std::optional<plg::mat4x4> ValueFromObject(PyObject* object) {

return g_py3lm.Matrix4x4ValueFromObject(object);

}

template<typename T>

std::optional<plg::vector<T>> ArrayFromObject(PyObject* arrayObject) {

if (!PyList_Check(arrayObject)) {

SetTypeError("Expected list", arrayObject);

return std::nullopt;

}

const Py_ssize_t size = PyList_Size(arrayObject);

plg::vector<T> array(static_cast<size_t>(size));

for (Py_ssize_t i = 0; i < size; ++i) {

if (PyObject* const valueObject = PyList_GetItem(arrayObject, i)) {

if (auto value = ValueFromObject<T>(valueObject)) {

array[static_cast<size_t>(i)] = std::move(*value);

continue;

}

}

return std::nullopt;

}

return array;

}

std::optional<void*> GetOrCreateFunctionValue(const Method& method, PyObject* object) {

return g_py3lm.GetOrCreateFunctionValue(method, object);

}

void SetFallbackReturn(ValueType retType, ReturnSlot& ret) {

switch (retType) {

case ValueType::Void:

break;

case ValueType::Bool:

ret.Set<bool>({});

break;

case ValueType::Char8:

ret.Set<char>({});

break;

case ValueType::Char16:

ret.Set<char16_t>({});

break;

case ValueType::Int8:

ret.Set<int8_t>({});

break;

case ValueType::Int16:

ret.Set<int16_t>({});

break;

case ValueType::Int32:

ret.Set<int32_t>({});

break;

case ValueType::Int64:

ret.Set<int64_t>({});

break;

case ValueType::UInt8:

ret.Set<uint8_t>({});

break;

case ValueType::UInt16:

ret.Set<uint16_t>({});

break;

case ValueType::UInt32:

ret.Set<uint32_t>({});

break;

case ValueType::UInt64:

ret.Set<uint64_t>({});

break;

case ValueType::Pointer:

ret.Set<uintptr_t>({});

break;

case ValueType::Float:

ret.Set<float>({});

break;

case ValueType::Double:

ret.Set<double>({});

break;

case ValueType::Function:

ret.Set<void*>(nullptr);

break;

case ValueType::String:

ret.Construct<plg::string>();

break;

case ValueType::Any:

ret.Construct<plg::any>();

break;

case ValueType::ArrayBool:

ret.Construct<plg::vector<bool>>();

break;

case ValueType::ArrayChar8:

ret.Construct<plg::vector<char>>();

break;

case ValueType::ArrayChar16:

ret.Construct<plg::vector<char16_t>>();

break;

case ValueType::ArrayInt8:

ret.Construct<plg::vector<int8_t>>();

break;

case ValueType::ArrayInt16:

ret.Construct<plg::vector<int16_t>>();

break;

case ValueType::ArrayInt32:

ret.Construct<plg::vector<int32_t>>();

break;

case ValueType::ArrayInt64:

ret.Construct<plg::vector<int64_t>>();

break;

case ValueType::ArrayUInt8:

ret.Construct<plg::vector<uint8_t>>();

break;

case ValueType::ArrayUInt16:

ret.Construct<plg::vector<uint16_t>>();

break;

case ValueType::ArrayUInt32:

ret.Construct<plg::vector<uint32_t>>();

break;

case ValueType::ArrayUInt64:

ret.Construct<plg::vector<uint64_t>>();

break;

case ValueType::ArrayPointer:

ret.Construct<plg::vector<void*>>();

break;

case ValueType::ArrayFloat:

ret.Construct<plg::vector<float>>();

break;

case ValueType::ArrayDouble:

ret.Construct<plg::vector<double>>();

break;

case ValueType::ArrayString:

ret.Construct<plg::vector<plg::string>>();

break;

case ValueType::ArrayAny:

ret.Construct<plg::vector<plg::any>>();

break;

case ValueType::ArrayVector2:

ret.Construct<plg::vector<plg::vec2>>();

break;

case ValueType::ArrayVector3:

ret.Construct<plg::vector<plg::vec3>>();

break;

case ValueType::ArrayVector4:

ret.Construct<plg::vector<plg::vec4>>();

break;

case ValueType::ArrayMatrix4x4:

ret.Construct<plg::vector<plg::mat4x4>>();

break;

case ValueType::Vector2:

ret.Set<plg::vec2>({});

break;

case ValueType::Vector3:

ret.Set<plg::vec3>({});

break;

case ValueType::Vector4:

ret.Set<plg::vec4>({});

break;

case ValueType::Matrix4x4:

ret.Set<plg::mat4x4>({});

break;

default: {

const std::string error(std::format(LOG_PREFIX "SetFallbackReturn unsupported type {:#x}", static_cast<uint8_t>(retType)));

g_py3lm.LogFatal(error);

std::terminate();

}

}

}

bool SetReturn(PyObject* result, const Property& retType, ReturnSlot& ret) {

switch (retType.GetType()) {

case ValueType::Void:

return true;

case ValueType::Bool:

if (auto value = ValueFromObject<bool>(result)) {

ret.Set<bool>(*value);

return true;

}

break;

case ValueType::Char8:

if (auto value = ValueFromObject<char>(result)) {

ret.Set<char>(*value);

return true;

}

break;

case ValueType::Char16:

if (auto value = ValueFromObject<char16_t>(result)) {

ret.Set<char16_t>(*value);

return true;

}

break;

case ValueType::Int8:

if (auto value = ValueFromObject<int8_t>(result)) {

ret.Set<int8_t>(*value);

return true;

}

break;

case ValueType::Int16:

if (auto value = ValueFromObject<int16_t>(result)) {

ret.Set<int16_t>(*value);

return true;

}

break;

case ValueType::Int32:

if (auto value = ValueFromObject<int32_t>(result)) {

ret.Set<int32_t>(*value);

return true;

}

break;

case ValueType::Int64:

if (auto value = ValueFromObject<int64_t>(result)) {

ret.Set<int64_t>(*value);

return true;

}

break;

case ValueType::UInt8:

if (auto value = ValueFromObject<uint8_t>(result)) {

ret.Set<uint8_t>(*value);

return true;

}

break;

case ValueType::UInt16:

if (auto value = ValueFromObject<uint16_t>(result)) {

ret.Set<uint16_t>(*value);

return true;

}

break;

case ValueType::UInt32:

if (auto value = ValueFromObject<uint32_t>(result)) {

ret.Set<uint32_t>(*value);

return true;

}

break;

case ValueType::UInt64:

if (auto value = ValueFromObject<uint64_t>(result)) {

ret.Set<uint64_t>(*value);

return true;

}

break;

case ValueType::Pointer:

if (auto value = ValueFromObject<void*>(result)) {

ret.Set<void*>(*value);

return true;

}

break;

case ValueType::Float:

if (auto value = ValueFromObject<float>(result)) {

ret.Set<float>(*value);

return true;

}

break;

case ValueType::Double:

if (auto value = ValueFromObject<double>(result)) {

ret.Set<double>(*value);

return true;

}

break;

case ValueType::Function:

if (auto value = GetOrCreateFunctionValue(*retType.GetPrototype(), result)) {

ret.Set<void*>(*value);

return true;

}

break;

case ValueType::String:

if (auto value = ValueFromObject<plg::string>(result)) {

ret.Construct<plg::string>(std::move(*value));

return true;

}

break;

case ValueType::Any:

if (auto value = ValueFromObject<plg::any>(result)) {

ret.Construct<plg::any>(std::move(*value));

return true;

}

break;

case ValueType::ArrayBool:

if (auto value = ArrayFromObject<bool>(result)) {

ret.Construct<plg::vector<bool>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayChar8:

if (auto value = ArrayFromObject<char>(result)) {

ret.Construct<plg::vector<char>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayChar16:

if (auto value = ArrayFromObject<char16_t>(result)) {

ret.Construct<plg::vector<char16_t>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayInt8:

if (auto value = ArrayFromObject<int8_t>(result)) {

ret.Construct<plg::vector<int8_t>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayInt16:

if (auto value = ArrayFromObject<int16_t>(result)) {

ret.Construct<plg::vector<int16_t>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayInt32:

if (auto value = ArrayFromObject<int32_t>(result)) {

ret.Construct<plg::vector<int32_t>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayInt64:

if (auto value = ArrayFromObject<int64_t>(result)) {

ret.Construct<plg::vector<int64_t>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayUInt8:

if (auto value = ArrayFromObject<uint8_t>(result)) {

ret.Construct<plg::vector<uint8_t>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayUInt16:

if (auto value = ArrayFromObject<uint16_t>(result)) {

ret.Construct<plg::vector<uint16_t>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayUInt32:

if (auto value = ArrayFromObject<uint32_t>(result)) {

ret.Construct<plg::vector<uint32_t>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayUInt64:

if (auto value = ArrayFromObject<uint64_t>(result)) {

ret.Construct<plg::vector<uint64_t>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayPointer:

if (auto value = ArrayFromObject<void*>(result)) {

ret.Construct<plg::vector<void*>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayFloat:

if (auto value = ArrayFromObject<float>(result)) {

ret.Construct<plg::vector<float>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayDouble:

if (auto value = ArrayFromObject<double>(result)) {

ret.Construct<plg::vector<double>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayString:

if (auto value = ArrayFromObject<plg::string>(result)) {

ret.Construct<plg::vector<plg::string>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayAny:

if (auto value = ArrayFromObject<plg::any>(result)) {

ret.Construct<plg::vector<plg::any>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayVector2:

if (auto value = ArrayFromObject<plg::vec2>(result)) {

ret.Construct<plg::vector<plg::vec2>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayVector3:

if (auto value = ArrayFromObject<plg::vec3>(result)) {

ret.Construct<plg::vector<plg::vec3>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayVector4:

if (auto value = ArrayFromObject<plg::vec4>(result)) {

ret.Construct<plg::vector<plg::vec4>>(std::move(*value));

return true;

}

break;

case ValueType::ArrayMatrix4x4:

if (auto value = ArrayFromObject<plg::mat4x4>(result)) {

ret.Construct<plg::vector<plg::mat4x4>>(std::move(*value));

return true;

}

break;

case ValueType::Vector2:

if (auto value = ValueFromObject<plg::vec2>(result)) {

ret.Set<plg::vec2>(*value);

return true;

}

break;

case ValueType::Vector3:

if (auto value = ValueFromObject<plg::vec3>(result)) {

ret.Set<plg::vec3>(*value);

return true;

}

break;

case ValueType::Vector4:

if (auto value = ValueFromObject<plg::vec4>(result)) {

ret.Set<plg::vec4>(*value);

return true;

}

break;

case ValueType::Matrix4x4:

if (auto value = ValueFromObject<plg::mat4x4>(result)) {

ret.Set<plg::mat4x4>(*value);

return true;

}

break;

default: {

const std::string error(std::format(LOG_PREFIX "SetReturn unsupported type {:#x}", static_cast<uint8_t>(retType.GetType())));

g_py3lm.LogFatal(error);

std::terminate();

}

}

return false;

}

bool SetRefParam(PyObject* object, const Property& paramType, const ParametersSpan& params, size_t index) {

switch (paramType.GetType()) {

case ValueType::Bool: