@@ -21,7 +21,8 @@ public:
|
||||
/**
|
||||
* @brief Constructs a context.
|
||||
*/
|
||||
context();
|
||||
context()
|
||||
: m_thingAllocator(m_thingArena) {}
|
||||
|
||||
~context() = default;
|
||||
|
||||
@@ -124,6 +125,8 @@ public:
|
||||
* @return The thing allocator.
|
||||
*/
|
||||
thing_allocator<std::byte> thing_alloc() const { return m_thingAllocator; }
|
||||
|
||||
thing_type_store& thing_type_store() { return m_thingTypeStore; }
|
||||
private:
|
||||
handle_container<mod_h> m_modules;
|
||||
handle_container<thing_h> m_things;
|
||||
@@ -131,6 +134,7 @@ private:
|
||||
|
||||
furlang::arena m_thingArena;
|
||||
thing_allocator<std::byte> m_thingAllocator;
|
||||
class thing_type_store m_thingTypeStore;
|
||||
};
|
||||
|
||||
} // namespace furvm
|
||||
|
||||
@@ -164,6 +164,10 @@ public:
|
||||
* @brief Executes next instruction.
|
||||
*/
|
||||
void step();
|
||||
private:
|
||||
thing_type thing_type_impl(mod_h mod, mod_type type) const;
|
||||
|
||||
thing_type* thing_type(const mod_h& mod, const mod_type& type) const;
|
||||
private:
|
||||
executor_flags m_flags{}; // NOLINT(bugprone-invalid-enum-default-initialization)
|
||||
context_p m_context;
|
||||
|
||||
@@ -37,7 +37,7 @@ struct import_function {
|
||||
* @brief Function signature.
|
||||
*/
|
||||
struct function_sig {
|
||||
std::vector<type_h> params;
|
||||
std::vector<mod_type_h> params;
|
||||
|
||||
bool operator==(const function_sig& rhs) const { return params == rhs.params; }
|
||||
|
||||
@@ -190,9 +190,7 @@ private:
|
||||
namespace detail {
|
||||
|
||||
struct function_sig_hash {
|
||||
std::size_t operator()(const function_sig& signature) const {
|
||||
return furlang::utility::vector_hash<type_h, detail::handle_hash<type_h>>{}(signature.params);
|
||||
}
|
||||
std::size_t operator()(const function_sig& signature) const;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
+12
-20
@@ -115,6 +115,12 @@ using function_h = handle<function, refcount_header<function_id>>;
|
||||
|
||||
// module.hpp
|
||||
|
||||
struct mod_type;
|
||||
|
||||
using mod_type_id = std::uint32_t;
|
||||
|
||||
using mod_type_h = handle<mod_type, generic_header<mod_type_id>>;
|
||||
|
||||
/**
|
||||
* @class mod
|
||||
* @brief Module.
|
||||
@@ -138,34 +144,20 @@ using mod_id = std::string;
|
||||
*/
|
||||
using mod_h = handle<mod, refcount_header<mod_id>>;
|
||||
|
||||
// thing_allocator.hpp
|
||||
|
||||
template <typename T>
|
||||
class thing_allocator;
|
||||
|
||||
// thing.hpp
|
||||
|
||||
/**
|
||||
* @enum type_t
|
||||
* @brief Type of the thing's type.
|
||||
*/
|
||||
enum class type_t : std::uint32_t;
|
||||
|
||||
/**
|
||||
* @struct type
|
||||
* @brief Thing type.
|
||||
*/
|
||||
struct type;
|
||||
|
||||
using type_p = std::shared_ptr<type>;
|
||||
|
||||
using type_id = std::uint32_t;
|
||||
|
||||
using type_h = handle<type_p, generic_header<type_id>>;
|
||||
|
||||
/**
|
||||
* @class bad_thing_access
|
||||
* @brief Bad thing access exception.
|
||||
*/
|
||||
class bad_thing_access;
|
||||
|
||||
template <typename T>
|
||||
class thing_allocator;
|
||||
using thing_type_id = std::uint32_t;
|
||||
|
||||
/**
|
||||
* @class thing
|
||||
|
||||
@@ -5,7 +5,6 @@
|
||||
#include "furvm/function.hpp"
|
||||
#include "furvm/fwd.hpp"
|
||||
#include "furvm/handle.hpp"
|
||||
#include "furvm/type.hpp" // IWYU pragma: keep
|
||||
|
||||
#include <functional>
|
||||
#include <istream>
|
||||
@@ -18,6 +17,125 @@
|
||||
|
||||
namespace furvm {
|
||||
|
||||
struct mod_type {
|
||||
using primitive = std::uint64_t;
|
||||
|
||||
struct array {
|
||||
mod_type_id typeId;
|
||||
std::size_t size;
|
||||
};
|
||||
|
||||
struct imprt {
|
||||
mod_id modId;
|
||||
mod_type_id typeId;
|
||||
};
|
||||
|
||||
enum type {
|
||||
Primitive = 0,
|
||||
Array,
|
||||
|
||||
Import,
|
||||
Count,
|
||||
} type;
|
||||
union value {
|
||||
std::nullptr_t null = nullptr;
|
||||
primitive primitive;
|
||||
array array;
|
||||
imprt imprt;
|
||||
|
||||
value() = default;
|
||||
|
||||
value(std::uint64_t primitive)
|
||||
: primitive(primitive) {}
|
||||
|
||||
value(mod_type_id id, std::size_t size)
|
||||
: array({}) {
|
||||
array.typeId = id;
|
||||
array.size = size;
|
||||
}
|
||||
|
||||
template <typename ModIdFwd, typename = std::enable_if_t<std::is_constructible_v<mod_id, ModIdFwd>>>
|
||||
value(ModIdFwd&& modId, mod_type_id typeId)
|
||||
: imprt({}) {
|
||||
imprt.modId = std::forward<ModIdFwd>(modId);
|
||||
imprt.typeId = typeId;
|
||||
}
|
||||
|
||||
~value() {}
|
||||
|
||||
value(value&& other) = delete;
|
||||
value& operator=(value&& other) = delete;
|
||||
value(const value& other) = delete;
|
||||
value& operator=(const value& other) = delete;
|
||||
} value;
|
||||
|
||||
mod_type(primitive primitive)
|
||||
: type(Primitive), value(primitive) {}
|
||||
|
||||
mod_type(mod_type_id id, std::size_t size)
|
||||
: type(Array), value(id, size) {}
|
||||
|
||||
template <typename ModIdFwd, typename = std::enable_if_t<std::is_constructible_v<mod_id, ModIdFwd>>>
|
||||
mod_type(ModIdFwd&& modId, mod_type_id typeId)
|
||||
: type(Import), value(std::forward<ModIdFwd>(modId), typeId) {}
|
||||
|
||||
~mod_type() {
|
||||
switch (type) {
|
||||
case Array: value.array.~array(); break;
|
||||
case Import: value.imprt.~imprt(); break;
|
||||
case Primitive:
|
||||
case Count:
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
mod_type(mod_type&& other) noexcept
|
||||
: type(other.type) {
|
||||
switch (type) {
|
||||
case Primitive: new (&value.primitive) primitive(other.value.primitive); break;
|
||||
case Array: new (&value.array) array(other.value.array); break;
|
||||
case Import: new (&value.imprt) imprt(std::move(other.value.imprt)); break;
|
||||
case Count: break;
|
||||
}
|
||||
other.type = Count;
|
||||
}
|
||||
|
||||
mod_type& operator=(mod_type&& other) noexcept {
|
||||
if (this == &other) return *this;
|
||||
type = other.type;
|
||||
switch (type) {
|
||||
case Primitive: new (&value.primitive) primitive(other.value.primitive); break;
|
||||
case Array: new (&value.array) array(other.value.array); break;
|
||||
case Import: new (&value.imprt) imprt(std::move(other.value.imprt)); break;
|
||||
case Count: break;
|
||||
}
|
||||
other.type = Count;
|
||||
return *this;
|
||||
}
|
||||
|
||||
mod_type(const mod_type& other)
|
||||
: type(other.type) {
|
||||
switch (type) {
|
||||
case Primitive: new (&value.primitive) primitive(other.value.primitive); break;
|
||||
case Array: new (&value.array) array(other.value.array); break;
|
||||
case Import: new (&value.imprt) imprt(other.value.imprt); break;
|
||||
case Count: break;
|
||||
}
|
||||
}
|
||||
|
||||
mod_type& operator=(const mod_type& other) {
|
||||
if (this == &other) return *this;
|
||||
type = other.type;
|
||||
switch (type) {
|
||||
case Primitive: new (&value.primitive) primitive(other.value.primitive); break;
|
||||
case Array: new (&value.array) array(other.value.array); break;
|
||||
case Import: new (&value.imprt) imprt(other.value.imprt); break;
|
||||
case Count: break;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
class mod {
|
||||
friend class function;
|
||||
friend class serializer;
|
||||
@@ -181,7 +299,7 @@ public:
|
||||
*/
|
||||
template <typename... Args>
|
||||
auto emplace_type(Args&&... args) {
|
||||
if constexpr (std::is_constructible_v<type_p, Args...>) {
|
||||
if constexpr (std::is_constructible_v<mod_type, Args...>) {
|
||||
return m_types.emplace_back(std::forward<Args>(args)...);
|
||||
} else {
|
||||
return m_types.emplace(std::forward<Args>(args)...);
|
||||
@@ -245,7 +363,7 @@ private:
|
||||
std::unordered_map<function_id, pair_type> m_functionMap;
|
||||
handle_container<function_h> m_functions;
|
||||
|
||||
handle_container<type_h> m_types;
|
||||
handle_container<mod_type_h> m_types;
|
||||
|
||||
std::unordered_map<std::string, native_function> m_nativeFunctions;
|
||||
};
|
||||
|
||||
+193
-124
@@ -1,38 +1,142 @@
|
||||
#ifndef FURVM_THING_HPP
|
||||
#define FURVM_THING_HPP
|
||||
|
||||
#include "furlang/arena.hpp"
|
||||
#include "furlang/utility/hash.hpp"
|
||||
#include "furvm/exceptions.hpp"
|
||||
#include "furvm/fwd.hpp"
|
||||
#include "furvm/module.hpp"
|
||||
#include "furvm/type.hpp"
|
||||
#include "furvm/thing_allocator.hpp" // IWYU pragma: keep
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <cstring>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <limits>
|
||||
#include <new>
|
||||
#include <stdexcept>
|
||||
#include <unordered_map>
|
||||
#include <utility>
|
||||
|
||||
namespace furvm {
|
||||
|
||||
struct thing_type {
|
||||
using primitive = std::uint64_t;
|
||||
|
||||
struct array {
|
||||
thing_type* type;
|
||||
std::size_t size;
|
||||
};
|
||||
|
||||
enum type { // NOLINT
|
||||
Primitive = 0,
|
||||
Array,
|
||||
|
||||
Count,
|
||||
} type;
|
||||
union value {
|
||||
primitive primitive;
|
||||
array array;
|
||||
|
||||
value(std::uint64_t primitive)
|
||||
: primitive(primitive) {}
|
||||
|
||||
value(thing_type* type, std::size_t size)
|
||||
: array({}) {
|
||||
array.type = type;
|
||||
array.size = size;
|
||||
}
|
||||
} value;
|
||||
|
||||
static constexpr thing_type_id INVALID_ID = std::numeric_limits<thing_type_id>::max();
|
||||
|
||||
thing_type_id id = INVALID_ID;
|
||||
|
||||
bool operator==(const thing_type& other) const {
|
||||
if (type != other.type) return false;
|
||||
switch (type) {
|
||||
case Primitive: return value.primitive == other.value.primitive;
|
||||
case Array: return *value.array.type == *other.value.array.type && value.array.size == other.value.array.size;
|
||||
case Count: break;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool operator!=(const thing_type& other) const { return !this->operator==(other); }
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
struct thing_type_hash {
|
||||
std::size_t operator()(const thing_type& type) const {
|
||||
std::size_t seed = std::hash<decltype(type.type)>{}(type.type);
|
||||
switch (type.type) {
|
||||
case thing_type::Primitive:
|
||||
seed =
|
||||
furlang::utility::hash_combine(seed, std::hash<decltype(type.value.primitive)>{}(type.value.primitive));
|
||||
return seed;
|
||||
case thing_type::Array:
|
||||
seed = furlang::utility::hash_combine(seed, thing_type_hash{}(*type.value.array.type));
|
||||
seed = furlang::utility::hash_combine(seed,
|
||||
std::hash<decltype(type.value.array.size)>{}(type.value.array.size));
|
||||
return seed;
|
||||
case thing_type::Count: break;
|
||||
}
|
||||
throw std::runtime_error("unreachable");
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
class thing_type_store {
|
||||
public:
|
||||
thing_type* insert(thing_type& type) {
|
||||
if (auto it = m_typeMap.find(type); it != m_typeMap.end()) return m_map[type.id = it->second];
|
||||
if (type.id == thing_type::INVALID_ID) type.id = m_counter++;
|
||||
|
||||
thing_type* ptr = m_arena.allocate<thing_type>(type);
|
||||
m_map[type.id] = ptr;
|
||||
m_typeMap[type] = type.id;
|
||||
return ptr;
|
||||
}
|
||||
|
||||
thing_type* at(thing_type_id id) const {
|
||||
if (auto it = m_map.find(id); it != m_map.end()) return it->second;
|
||||
return nullptr;
|
||||
}
|
||||
private:
|
||||
furlang::arena m_arena;
|
||||
std::unordered_map<thing_type_id, thing_type*> m_map;
|
||||
std::unordered_map<thing_type, thing_type_id, detail::thing_type_hash> m_typeMap;
|
||||
thing_type_id m_counter = 0;
|
||||
};
|
||||
|
||||
template <template <typename> typename Allocator>
|
||||
class thing final {
|
||||
friend class executor;
|
||||
public:
|
||||
using allocator_type = Allocator<std::byte>; /**< Allocator type. */
|
||||
public:
|
||||
using s8 = std::int8_t;
|
||||
using s16 = std::int16_t;
|
||||
using s32 = std::int32_t;
|
||||
using s64 = std::int64_t;
|
||||
|
||||
using mod_container = std::shared_ptr<handle_container<mod_h>>;
|
||||
union array {
|
||||
std::byte flat[];
|
||||
struct {
|
||||
std::size_t size;
|
||||
std::byte* data;
|
||||
} dynamic;
|
||||
};
|
||||
public:
|
||||
/**
|
||||
* @brief Constructs a thing.
|
||||
*
|
||||
* @param type Thing type reference.
|
||||
* @param type Thing type.
|
||||
* @param allocator Allocator for the thing's data.
|
||||
*/
|
||||
thing(const type_ref& type, const mod_container& modules = nullptr, const allocator_type& allocator = {})
|
||||
: m_type(type), m_size(compute_size(resolve_type(type, modules))), m_modules(modules), m_allocator(allocator) {
|
||||
thing(const thing_type& type, const allocator_type& allocator = {})
|
||||
: m_type(type), m_size(compute_size(type)), m_allocator(allocator) {
|
||||
// TODO: Account for alignment
|
||||
m_data = m_allocator.allocate(m_size);
|
||||
std::memset(m_data, 0, m_size);
|
||||
@@ -49,14 +153,10 @@ public:
|
||||
* @brief Move constructor.
|
||||
*/
|
||||
thing(thing&& other) noexcept
|
||||
: m_type(std::move(other.m_type)),
|
||||
m_data(other.m_data),
|
||||
m_size(other.m_size),
|
||||
m_modules(std::move(other.m_modules)),
|
||||
m_allocator(std::move(other.m_allocator)) {
|
||||
other.m_type = {};
|
||||
other.m_data = nullptr;
|
||||
other.m_size = 0;
|
||||
: m_type(other.m_type), m_data(other.m_data), m_size(other.m_size), m_allocator(std::move(other.m_allocator)) {
|
||||
other.m_type.type = thing_type::Count;
|
||||
other.m_data = nullptr;
|
||||
other.m_size = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -64,20 +164,17 @@ public:
|
||||
*/
|
||||
thing& operator=(thing&& other) noexcept {
|
||||
if (this == &other) return *this;
|
||||
m_type = other.m_type;
|
||||
m_data = other.m_data;
|
||||
m_modules = std::move(other.m_modules);
|
||||
m_allocator = std::move(other.m_allocator);
|
||||
other.m_type = {};
|
||||
other.m_data = nullptr;
|
||||
other.m_size = 0;
|
||||
m_type = other.m_type;
|
||||
m_data = other.m_data;
|
||||
m_allocator = std::move(other.m_allocator);
|
||||
other.m_type.type = thing_type::Count;
|
||||
other.m_data = nullptr;
|
||||
other.m_size = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
thing(const thing&) = delete;
|
||||
thing& operator=(const thing&) = delete;
|
||||
public:
|
||||
void assign_mod_container(const mod_container& modules) { m_modules = modules; }
|
||||
public:
|
||||
/**
|
||||
* @brief Returns a clone of the thing.
|
||||
@@ -85,30 +182,17 @@ public:
|
||||
* @return A clone of this thing.
|
||||
*/
|
||||
thing clone() const {
|
||||
auto type = resolve_type(m_type, m_modules);
|
||||
if (m_size == 0) {
|
||||
return reference();
|
||||
}
|
||||
if (m_size == 0) return reference();
|
||||
|
||||
thing res(type, m_modules, m_allocator);
|
||||
switch (type->t) {
|
||||
case type_t::Primitive:
|
||||
case type_t::Array: {
|
||||
copy_list(*type.type, res.get<array_t>(), get<array_t>());
|
||||
} break;
|
||||
case type_t::Import:
|
||||
default: throw std::runtime_error("unreachable");
|
||||
thing res(m_type, m_allocator);
|
||||
switch (m_type.type) {
|
||||
case thing_type::Primitive: std::memcpy(res.m_data, m_data, m_size); return std::move(res);
|
||||
case thing_type::Array: copy_list(m_type, res.get<array>(), get<array>()); return std::move(res);
|
||||
case thing_type::Count: break;
|
||||
}
|
||||
return std::move(res);
|
||||
throw std::runtime_error("unreachable");
|
||||
}
|
||||
public:
|
||||
/**
|
||||
* @brief Returns the thing's type reference.
|
||||
*
|
||||
* @return The type reference.
|
||||
*/
|
||||
auto type() { return m_type; }
|
||||
|
||||
/**
|
||||
* @brief Returns the thing's type reference.
|
||||
*
|
||||
@@ -137,7 +221,7 @@ public:
|
||||
*/
|
||||
template <typename T>
|
||||
T& get() {
|
||||
std::size_t size = m_size > 0 ? m_size : compute_size_na(resolve_type(m_type, m_modules));
|
||||
std::size_t size = m_size > 0 ? m_size : compute_size_na(m_type);
|
||||
if (size != sizeof(T)) throw bad_thing_access();
|
||||
return *std::launder(reinterpret_cast<T*>(m_data));
|
||||
}
|
||||
@@ -149,7 +233,7 @@ public:
|
||||
*/
|
||||
template <typename T>
|
||||
const T& get() const {
|
||||
std::size_t size = m_size > 0 ? m_size : compute_size_na(resolve_type(m_type, m_modules));
|
||||
std::size_t size = m_size > 0 ? m_size : compute_size_na(m_type);
|
||||
if (size != sizeof(T)) throw bad_thing_access();
|
||||
return *std::launder(reinterpret_cast<const T*>(m_data));
|
||||
}
|
||||
@@ -247,79 +331,68 @@ public:
|
||||
*
|
||||
* @return The integer value.
|
||||
*/
|
||||
long_t integer() const {
|
||||
if (m_type->t != type_t::Primitive) throw bad_thing_access();
|
||||
switch (m_type->primitive) {
|
||||
case sizeof(byte_t): return get<byte_t>();
|
||||
case sizeof(short_t): return get<short_t>();
|
||||
case sizeof(int_t): return get<int_t>();
|
||||
case sizeof(long_t): return get<long_t>();
|
||||
s64 integer() const {
|
||||
if (m_type.type != thing_type::Primitive) throw bad_thing_access();
|
||||
switch (m_type.value.primitive) {
|
||||
case sizeof(s8): return get<s8>();
|
||||
case sizeof(s16): return get<s16>();
|
||||
case sizeof(s32): return get<s32>();
|
||||
case sizeof(s64): return get<s64>();
|
||||
default: throw std::runtime_error("unreachable");
|
||||
}
|
||||
}
|
||||
|
||||
thing reference() const { return { m_type, m_data, m_modules, m_allocator }; }
|
||||
thing reference() const { return { m_type, m_data, m_allocator }; }
|
||||
|
||||
constexpr bool is_reference() const { return m_size == 0; }
|
||||
|
||||
void resize(long_t newSize) {
|
||||
if (m_type->t != type_t::Array) throw bad_thing_access();
|
||||
if (m_type->array.size > 0) throw std::runtime_error("cannot resize a static array");
|
||||
void resize(s64 newSize) {
|
||||
if (m_type.type != thing_type::Array) throw bad_thing_access();
|
||||
if (m_type.value.array.size > 0) throw std::runtime_error("cannot resize a static array");
|
||||
|
||||
auto& array = get<array_t>();
|
||||
auto& array = get<union array>();
|
||||
if (newSize < 0 || newSize == array.dynamic.size) return;
|
||||
std::size_t innerSize = compute_size_na(*m_type->array.type);
|
||||
std::size_t innerSize = compute_size_na(*m_type.value.array.type);
|
||||
std::byte* newData = new std::byte[innerSize * newSize];
|
||||
std::memcpy(newData, array.dynamic.data, innerSize * std::min(array.dynamic.size, newSize));
|
||||
std::memcpy(newData,
|
||||
array.dynamic.data,
|
||||
innerSize * std::min(static_cast<std::int64_t>(array.dynamic.size), newSize));
|
||||
array.dynamic.size = newSize;
|
||||
delete[] array.dynamic.data;
|
||||
array.dynamic.data = newData;
|
||||
}
|
||||
|
||||
thing at(long_t index) const {
|
||||
if (m_type->t != type_t::Array) throw bad_thing_access();
|
||||
thing at(s64 index) const {
|
||||
if (m_type.type != thing_type::Array) throw bad_thing_access();
|
||||
|
||||
std::size_t elementSize = compute_size_na(*m_type->array.type);
|
||||
if (m_type->array.size == 0) {
|
||||
auto& array = get<array_t>();
|
||||
std::size_t elementSize = compute_size_na(*m_type.value.array.type);
|
||||
if (m_type.value.array.size == 0) {
|
||||
auto& array = get<union array>();
|
||||
if (index < 0 || index >= array.dynamic.size) throw std::out_of_range("index out of range");
|
||||
return { { m_type.mod, m_type->array.type },
|
||||
array.dynamic.data + (index * elementSize),
|
||||
m_modules,
|
||||
m_allocator };
|
||||
return { *m_type.value.array.type, array.dynamic.data + (index * elementSize), m_allocator };
|
||||
}
|
||||
|
||||
std::byte* data = reinterpret_cast<array_t*>(m_data)->data;
|
||||
if (index < 0 || index >= m_type->array.size) throw std::out_of_range("index out of range");
|
||||
return { { m_type.mod, m_type->array.type }, data + (index * elementSize), m_modules, m_allocator };
|
||||
std::byte* data = reinterpret_cast<array*>(m_data)->flat;
|
||||
if (index < 0 || index >= m_type.value.array.size) throw std::out_of_range("index out of range");
|
||||
return { *m_type.value.array.type, data + (index * elementSize), m_allocator };
|
||||
}
|
||||
|
||||
std::size_t size() const {
|
||||
if (m_type->t != type_t::Array) throw std::runtime_error("not an array");
|
||||
if (m_type->array.size == 0) return get<array_t>().dynamic.size;
|
||||
return m_type->array.size;
|
||||
}
|
||||
public:
|
||||
static type_ref resolve_type(const type_ref& initType, const mod_container& modules) {
|
||||
type_ref rsv = initType;
|
||||
while (rsv->t == type_t::Import) {
|
||||
auto mod = modules->at(initType->imp.mod);
|
||||
rsv = type_ref{ mod, mod->type_at(initType->imp.type) };
|
||||
}
|
||||
return rsv;
|
||||
if (m_type.type != thing_type::Array) throw bad_thing_access();
|
||||
return m_type.value.array.size == 0 ? get<array>().dynamic.size : m_type.value.array.size;
|
||||
}
|
||||
private:
|
||||
static void copy_list(const type_p& arrayType, array_t& dst, const array_t& src) {
|
||||
if (arrayType == nullptr || arrayType->t != type_t::Array || *arrayType->array.type == nullptr)
|
||||
static void copy_list(const thing_type& arrayType, array& dst, const array& src) {
|
||||
if (arrayType.type != thing_type::Array || arrayType.value.array.type == nullptr)
|
||||
throw std::runtime_error("invalid type");
|
||||
|
||||
auto innerType = *arrayType->array.type;
|
||||
const auto& innerType = *arrayType.value.array.type;
|
||||
std::size_t elementSize = compute_size_na(innerType);
|
||||
|
||||
std::byte* data = nullptr;
|
||||
const std::byte* srcData = nullptr;
|
||||
std::size_t size = 0;
|
||||
if (arrayType->array.size == 0) {
|
||||
if (arrayType.value.array.size == 0) {
|
||||
size = dst.dynamic.size = src.dynamic.size;
|
||||
if (dst.dynamic.size < 0) {
|
||||
dst.dynamic.data = nullptr;
|
||||
@@ -329,60 +402,57 @@ private:
|
||||
srcData = src.dynamic.data;
|
||||
data = dst.dynamic.data = new std::byte[dst.dynamic.size];
|
||||
} else {
|
||||
data = dst.data;
|
||||
srcData = src.data;
|
||||
size = arrayType->array.size;
|
||||
data = dst.flat;
|
||||
srcData = src.flat;
|
||||
size = arrayType.value.array.size;
|
||||
}
|
||||
|
||||
switch (innerType->t) {
|
||||
case type_t::Primitive: std::memcpy(dst.data, src.data, size); break;
|
||||
case type_t::Array:
|
||||
switch (innerType.type) {
|
||||
case thing_type::Primitive: std::memcpy(dst.flat, src.flat, size); return;
|
||||
case thing_type::Array:
|
||||
for (std::size_t i = 0; i < size; ++i) {
|
||||
copy_list(*innerType->array.type,
|
||||
*std::launder(reinterpret_cast<array_t*>(data + (i * elementSize))),
|
||||
*std::launder(reinterpret_cast<const array_t*>(srcData + (i * elementSize))));
|
||||
copy_list(*innerType.value.array.type,
|
||||
*std::launder(reinterpret_cast<array*>(data + (i * elementSize))),
|
||||
*std::launder(reinterpret_cast<const array*>(srcData + (i * elementSize))));
|
||||
}
|
||||
break;
|
||||
case type_t::Import: throw std::runtime_error("unresolved type");
|
||||
return;
|
||||
case thing_type::Count: break;
|
||||
}
|
||||
throw std::runtime_error("unreachable");
|
||||
}
|
||||
private:
|
||||
static std::size_t compute_size_na(const type_p& type) {
|
||||
switch (type->t) {
|
||||
case type_t::Primitive: return type->primitive;
|
||||
case type_t::Array: {
|
||||
if (type->array.size == 0) return sizeof(array_t);
|
||||
return compute_size_na(*type->array.type) * type->array.size;
|
||||
}
|
||||
case type_t::Import: throw std::runtime_error("unresolved type");
|
||||
static std::size_t compute_size_na(const thing_type& type) {
|
||||
switch (type.type) {
|
||||
case thing_type::Primitive: return type.value.primitive;
|
||||
case thing_type::Array:
|
||||
return type.value.array.size == 0 ? sizeof(array)
|
||||
: compute_size_na(*type.value.array.type) * type.value.array.size;
|
||||
case thing_type::Count: break;
|
||||
}
|
||||
|
||||
throw std::runtime_error("unreachable");
|
||||
}
|
||||
|
||||
static std::size_t compute_size_na(const type_ref& type) { return compute_size_na(*type.type); }
|
||||
|
||||
// NOTE: Align to 4 bytes
|
||||
static std::size_t compute_size(const type_p& type) { return (compute_size_na(type) + 3) & ~3; }
|
||||
static std::size_t compute_size(const type_ref& type) { return compute_size(*type.type); }
|
||||
static std::size_t compute_size(const thing_type& type) { return (compute_size_na(type) + 3) & ~3; }
|
||||
private:
|
||||
thing(const type_ref& type, std::byte* data, const mod_container& modules, const allocator_type& allocator = {})
|
||||
: m_type(type), m_size(0), m_data(data), m_modules(modules), m_allocator(allocator) {}
|
||||
thing(const thing_type& type, std::byte* data, const allocator_type& allocator = {})
|
||||
: m_type(type), m_size(0), m_data(data), m_allocator(allocator) {}
|
||||
private:
|
||||
template <typename Op>
|
||||
thing binary_op(const thing& rhs, const Op& op) const {
|
||||
if (m_type->t == type_t::Primitive && rhs.type()->t == type_t::Primitive) {
|
||||
type_ref type = m_type->primitive >= rhs.type()->primitive ? m_type : rhs.type();
|
||||
std::size_t size = std::max(m_type->primitive, rhs.type()->primitive);
|
||||
if (m_type.type == thing_type::Primitive && rhs.m_type.type == thing_type::Primitive) {
|
||||
thing_type resultType = m_type.value.primitive >= rhs.m_type.value.primitive ? m_type : rhs.m_type;
|
||||
std::size_t size = std::max(m_type.value.primitive, rhs.m_type.value.primitive);
|
||||
|
||||
long_t result = op(integer(), rhs.integer());
|
||||
s64 result = op(integer(), rhs.integer());
|
||||
|
||||
thing res(type, m_modules, m_allocator);
|
||||
thing res(resultType, m_allocator);
|
||||
switch (size) {
|
||||
case sizeof(byte_t): res.get<byte_t>() = result; break;
|
||||
case sizeof(short_t): res.get<short_t>() = result; break;
|
||||
case sizeof(int_t): res.get<int_t>() = result; break;
|
||||
case sizeof(long_t): res.get<long_t>() = result; break;
|
||||
case sizeof(s8): res.get<s8>() = result; break;
|
||||
case sizeof(s16): res.get<s16>() = result; break;
|
||||
case sizeof(s32): res.get<s32>() = result; break;
|
||||
case sizeof(s64): res.get<s64>() = result; break;
|
||||
default: throw std::runtime_error("unreachable");
|
||||
}
|
||||
return std::move(res);
|
||||
@@ -391,11 +461,10 @@ private:
|
||||
throw std::runtime_error("unexpected operation");
|
||||
}
|
||||
private:
|
||||
type_ref m_type;
|
||||
thing_type m_type;
|
||||
std::size_t m_size;
|
||||
std::byte* m_data;
|
||||
|
||||
mod_container m_modules;
|
||||
allocator_type m_allocator;
|
||||
};
|
||||
|
||||
|
||||
@@ -1,181 +0,0 @@
|
||||
#ifndef FURVM_TYPE_HPP
|
||||
#define FURVM_TYPE_HPP
|
||||
|
||||
#include "furvm/fwd.hpp"
|
||||
#include "furvm/handle.hpp" // IWYU pragma: keep
|
||||
|
||||
#include <cstdint>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace furvm {
|
||||
|
||||
enum class type_t : std::uint32_t {
|
||||
Primitive = 0,
|
||||
Array,
|
||||
|
||||
Import,
|
||||
};
|
||||
|
||||
using primitive_type = std::uint64_t;
|
||||
|
||||
/**
|
||||
* @brief Array type.
|
||||
*/
|
||||
struct array_type {
|
||||
type_h type; /**< Type of the array's elements. */
|
||||
|
||||
/**
|
||||
* @brief Size of the array.
|
||||
*
|
||||
* Size of the array. If size is equal to zero, then the array becomes dynamic.
|
||||
*/
|
||||
std::size_t size;
|
||||
|
||||
bool operator==(const array_type& rhs) const { return type == rhs.type && size == rhs.size; }
|
||||
bool operator!=(const array_type& rhs) const { return !this->operator==(rhs); }
|
||||
};
|
||||
|
||||
struct import_type {
|
||||
mod_id mod;
|
||||
type_id type;
|
||||
|
||||
bool operator==(const import_type& rhs) const { return mod == rhs.mod && type == rhs.type; }
|
||||
bool operator!=(const import_type& rhs) const { return !this->operator==(rhs); }
|
||||
};
|
||||
|
||||
struct type {
|
||||
type_t t;
|
||||
union {
|
||||
primitive_type primitive{};
|
||||
array_type array;
|
||||
import_type imp;
|
||||
};
|
||||
|
||||
type(type_t type)
|
||||
: t(type) {}
|
||||
|
||||
type(primitive_type primitive)
|
||||
: t(type_t::Primitive), primitive(primitive) {}
|
||||
|
||||
type(const type_h& type, std::size_t size = 0)
|
||||
: t(type_t::Array), array(array_type{ type, size }) {}
|
||||
|
||||
type(const array_type& list)
|
||||
: t(type_t::Array), array(list) {}
|
||||
|
||||
type(const import_type& imp)
|
||||
: t(type_t::Import), imp(imp) {}
|
||||
|
||||
~type() {
|
||||
switch (t) {
|
||||
case type_t::Array: array.~array_type(); break;
|
||||
case type_t::Import: imp.~import_type(); break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
type(type&& other) noexcept
|
||||
: t(other.t) {
|
||||
switch (t) {
|
||||
case type_t::Primitive: primitive = other.primitive; break;
|
||||
case type_t::Array: array = std::move(other.array); break;
|
||||
case type_t::Import: imp = std::move(other.imp); break;
|
||||
}
|
||||
}
|
||||
|
||||
type& operator=(type&& other) noexcept {
|
||||
if (this == &other) return *this;
|
||||
t = other.t;
|
||||
switch (t) {
|
||||
case type_t::Primitive: primitive = other.primitive; break;
|
||||
case type_t::Array: array = std::move(other.array); break;
|
||||
case type_t::Import: imp = std::move(other.imp); break;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
type(const type& other)
|
||||
: t(other.t) {
|
||||
switch (t) {
|
||||
case type_t::Primitive: primitive = other.primitive; break;
|
||||
case type_t::Array: array = other.array; break;
|
||||
case type_t::Import: imp = other.imp; break;
|
||||
}
|
||||
}
|
||||
|
||||
type& operator=(const type& other) {
|
||||
if (this == &other) return *this;
|
||||
t = other.t;
|
||||
switch (t) {
|
||||
case type_t::Primitive: primitive = other.primitive; break;
|
||||
case type_t::Array: array = other.array; break;
|
||||
case type_t::Import: imp = other.imp; break;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator==(const type& rhs) const {
|
||||
if (t != rhs.t) return false;
|
||||
switch (t) {
|
||||
case type_t::Primitive: return primitive == rhs.primitive;
|
||||
case type_t::Array: return array == rhs.array;
|
||||
case type_t::Import: return imp == rhs.imp;
|
||||
}
|
||||
throw std::runtime_error("unreachable");
|
||||
}
|
||||
|
||||
bool operator!=(const type& rhs) const { return !this->operator==(rhs); }
|
||||
};
|
||||
|
||||
using byte_t = std::int8_t; /**< A 1-byte integer. */
|
||||
using short_t = std::int16_t; /**< A 2-byte integer. */
|
||||
using int_t = std::int32_t; /**< A 4-byte integer. */
|
||||
using long_t = std::int64_t; /**< An 8-byte integer. */
|
||||
|
||||
/**
|
||||
* @brief Array type's data layout.
|
||||
*/
|
||||
union array_t {
|
||||
std::byte data[]; /**< Static array's elements' data. */
|
||||
struct {
|
||||
long_t size; /**< Size of the array (in items). */
|
||||
std::byte* data; /**< Pointer to dynamic array's elements' data array. */
|
||||
} dynamic; /**< Dynamic array's info. */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief A 1-byte integer thing type.
|
||||
*/
|
||||
inline static type byteType = { sizeof(byte_t) }; // NOLINT
|
||||
|
||||
/**
|
||||
* @brief A 2-byte integer thing type.
|
||||
*/
|
||||
inline static type shortType = { sizeof(short_t) }; // NOLINT
|
||||
|
||||
/**
|
||||
* @brief A 4-byte integer thing type.
|
||||
*/
|
||||
inline static type intType = { sizeof(int_t) }; // NOLINT
|
||||
|
||||
/**
|
||||
* @brief An 8-byte integer thing type.
|
||||
*/
|
||||
inline static type longType = { sizeof(long_t) }; // NOLINT
|
||||
|
||||
/**
|
||||
* @brief Reference to a type.
|
||||
*/
|
||||
struct type_ref {
|
||||
mod_h mod;
|
||||
type_h type;
|
||||
|
||||
class type* operator->() { return &**type; }
|
||||
const class type* operator->() const { return &**type; }
|
||||
};
|
||||
|
||||
} // namespace furvm
|
||||
|
||||
#endif // FURVM_TYPE_HPP
|
||||
Reference in New Issue
Block a user