VirtualMachine.mpp

export module CppUtils.Language.VirtualMachine;

import std;
import CppUtils.Container;
import CppUtils.Type;
import CppUtils.String.Concept;

// Ribosome

export namespace CppUtils::Language::VirtualMachine
{
	template<class... Funcs>
	using Functions = std::tuple<Funcs...>;
	using NoFunctions = Functions<>;

	template<class... Refs>
	using References = std::tuple<std::reference_wrapper<Refs>...>;
	using NoReferences = References<>;

	[[nodiscard]] inline auto makeReferences(auto&... variables) noexcept
	{
		return References{std::ref(variables)...};
	}

	template<class... Types, class Functions = NoFunctions, class References = NoReferences>
	[[nodiscard]] inline /* constexpr */ auto execute(
		String::StringView auto source,
		const Functions& functions = NoFunctions{},
		References&& references = NoReferences{})
		-> std::expected<void, std::string_view>
	{
		using namespace std::literals;
		static_assert(Type::Specializes<Functions, std::tuple>);
		static_assert(Type::Specializes<References, std::tuple>);

		constexpr auto types = std::make_tuple(Types{}...);
		constexpr auto nbFunctions = std::tuple_size_v<std::remove_cvref_t<decltype(functions)>>;
		constexpr auto nbReferences = std::tuple_size_v<std::remove_cvref_t<decltype(references)>>;

		auto stack = Container::Stack{};
		auto registers = std::unordered_map<std::size_t, std::size_t>{}; // constexpr en C++23
		auto lastStackPositions = std::stack<std::size_t>{};

		auto skipComment = [&source](std::size_t& position) -> void {
			while (++position < std::size(source) and source[position] != '/' and source[position] != '\n') {}
		};

		for (auto position = 0uz; position < std::size(source); ++position)
			switch (auto instruction = source[position]; instruction)
			{
			case '@':
				do
					++position;
				while (position < std::size(source) and source[position] != '@');
				break;

			case '[': stack.push(0uz); break;

			case ']':
				if (auto result = stack.drop(sizeof(std::size_t)); not result) [[unlikely]]
					return result;
				break;

			case '.': stack.push(position); break;

			case '{':
			{
				auto oldPosition = position++;
				for (auto counter = 1uz; position < std::size(source) and counter > 0; ++position)
					switch (auto instruction = source[position]; instruction)
					{
					case '\\': ++position; break;
					case '{': ++counter; break;
					case '}': --counter; break;
					case '/': skipComment(position); break;
					}
				if (position >= std::size(source)) [[unlikely]]
					return std::unexpected{"Missing '}'"sv};
				stack.push(position - 1);
				position = oldPosition;
				break;
			}

			case '/':
				skipComment(position);
				break;

			case '(':
				lastStackPositions.push(std::size(stack));
				break;

			case ')':
				stack.push(lastStackPositions.top());
				lastStackPositions.pop();
				break;

			case '#':
				if (auto startPosition = stack.template get<std::size_t>(); not startPosition) [[unlikely]]
					return std::unexpected{startPosition.error()};
				else if (auto result = stack.set(std::hash<decltype(source)>{}(decltype(source){std::cbegin(source) + static_cast<long long>(startPosition.value() + 1), std::cbegin(source) + static_cast<long long>(position - 1)})); not result) [[unlikely]]
					return result;
				break;

			case '*':
				if (auto newPosition = stack.template pop<std::size_t>(); not newPosition) [[unlikely]]
					return std::unexpected{newPosition.error()};
				else
					position = newPosition.value();
				break;

			case ';':
				if constexpr (nbFunctions == 0)
					return std::unexpected{"No function defined"sv};
				else if (auto functionId = stack.template pop<std::size_t>(); not functionId) [[unlikely]]
					return std::unexpected{functionId.error()};
				else if (functionId.value() >= nbFunctions) [[unlikely]]
					return std::unexpected{"Function identifier too large"sv};
				else if (auto argumentsPosition = stack.template pop<std::size_t>(); not argumentsPosition) [[unlikely]]
					return std::unexpected{argumentsPosition.error()};
				else if (argumentsPosition.value() > std::size(stack)) [[unlikely]]
					return std::unexpected{"Arguments position too high"sv};
				else if (auto result = Type::Tuple::visitAt(functions, functionId.value(), [&stack, functionOffset = std::size(stack) - argumentsPosition.value()](auto& function) { return stack.call(function, functionOffset); });
					not result) [[unlikely]]
					return std::unexpected{result.error()};
				break;

			case '"':
				if constexpr (nbReferences == 0)
					return std::unexpected{"No reference defined"sv};
				else if (auto identifier = stack.template pop<std::size_t>(); not identifier) [[unlikely]]
					return std::unexpected{identifier.error()};
				else if (identifier.value() >= nbReferences) [[unlikely]]
					return std::unexpected{"Reference identifier too large"sv};
				else if (auto result = Type::Tuple::visitAt(references, identifier.value(), [&stack](auto& reference) -> std::expected<void, std::string_view> {
					using ReferenceType = typename std::remove_reference_t<decltype(reference)>::type;
					if constexpr (not std::is_trivially_copyable_v<ReferenceType>)
						return std::unexpected{"Cannot copy a non-trivially copyable value"sv};
					else
						stack.push(reference.get());
					return {};
				});
					not result)
					return std::unexpected{result.error()};
				break;

			case '^':
				if constexpr (nbReferences == 0)
					return std::unexpected{"No reference defined"sv};
				else if (auto referenceId = stack.template pop<std::size_t>(); not referenceId) [[unlikely]]
					return std::unexpected{referenceId.error()};
				else if (referenceId.value() >= nbReferences) [[unlikely]]
					return std::unexpected{"Variable identifier too large"sv};
				else if (auto result = Type::Tuple::visitAt(references, referenceId.value(), [&stack](auto& reference) -> std::expected<void, std::string_view> {
					using ReferenceType = typename std::remove_reference_t<decltype(reference)>::type;
					if constexpr (std::is_const_v<ReferenceType>)
						return std::unexpected{"A constant cannot be modified"sv};
					else if constexpr (not std::is_trivially_copyable_v<ReferenceType>)
						return std::unexpected{"Cannot copy a non-trivially copyable value"sv};
					else if (auto result = stack.get<ReferenceType>(); not result) [[unlikely]]
						return std::unexpected{result.error()};
					else
						reference.get() = std::move(result.value());
					return {};
				});
					not result)
					return std::unexpected{result.error()};
				break;

			case '<':
				if (auto key = stack.template pop<std::size_t>(); not key) [[unlikely]]
					return std::unexpected{key.error()};
				else if (auto value = stack.template pop<std::size_t>(); not value) [[unlikely]]
					return std::unexpected{value.error()};
				else
					registers[key.value()] = value.value();
				break;

			case '>':
				if (auto key = stack.template get<std::size_t>(); not key) [[unlikely]]
					return std::unexpected{key.error()};
				else if (registers.contains(key.value())) [[likely]] {
					auto _ = stack.set(registers[key.value()]);
				} else
					return std::unexpected{"Unknown register key"sv};
				break;

			case '=':
				if constexpr (sizeof...(Types) == 0)
					return std::unexpected{"No type defined"sv};
				else if (auto typeId = stack.template pop<std::size_t>(); not typeId) [[unlikely]]
					return std::unexpected{typeId.error()};
				else if (auto result = Type::Tuple::visitAt(types, typeId.value(), [&stack](const auto& value) -> std::expected<void, std::string_view> {
					using Type = std::remove_cvref_t<decltype(value)>;
					if (auto lhs = stack.get<Type>(sizeof(Type)); not lhs) [[unlikely]]
						return std::unexpected{lhs.error()};
					else if (auto rhs = stack.get<Type>(); not rhs) [[unlikely]]
						return std::unexpected{rhs.error()};
					else
						return stack.set(lhs.value() == rhs.value(), sizeof(Type) * 2);
				});
					not result) [[unlikely]]
					return std::unexpected{result.error()};
				break;

			case '&':
				if (auto lhs = stack.get<bool>(sizeof(bool)); not lhs) [[unlikely]]
					return std::unexpected{lhs.error()};
				else if (auto rhs = stack.get<bool>(); not rhs) [[unlikely]]
					return std::unexpected{rhs.error()};
				else if (auto result = stack.set(lhs.value() and rhs.value(), sizeof(bool) * 2); not result) [[unlikely]]
					return std::unexpected{result.error()};
				break;

			case '|':
				if (auto lhs = stack.get<bool>(sizeof(bool)); not lhs) [[unlikely]]
					return std::unexpected{lhs.error()};
				else if (auto rhs = stack.get<bool>(); not rhs) [[unlikely]]
					return std::unexpected{rhs.error()};
				else if (auto result = stack.set(lhs.value() or rhs.value(), sizeof(bool) * 2); not result) [[unlikely]]
					return std::unexpected{result.error()};
				break;

			case ':':
				if constexpr (sizeof...(Types) == 0)
					return std::unexpected{"No type defined"sv};
				else if (auto typeId = stack.template pop<std::size_t>(); not typeId) [[unlikely]]
					return std::unexpected{typeId.error()};
				else if (auto result = Type::Tuple::visitAt(types, typeId.value(), [&stack](const auto& value) {
					return stack.push(value);
				});
					not result) [[unlikely]]
					return std::unexpected{result.error()};
				break;

			case '_':
				if constexpr (sizeof...(Types) == 0)
					return std::unexpected{"No type defined"sv};
				else if (auto typeId = stack.template pop<std::size_t>(); not typeId) [[unlikely]]
					return std::unexpected{typeId.error()};
				else if (auto result = Type::Tuple::visitAt(types, typeId.value(), [&stack](const auto& value) {
					return stack.drop(sizeof(std::remove_cvref_t<decltype(value)>));
				});
					not result) [[unlikely]]
					return std::unexpected{result.error()};
				break;

			case '~':
				if (auto identifier = stack.template pop<std::size_t>(); not identifier) [[unlikely]]
					return std::unexpected{identifier.error()};
				else
					registers.erase(identifier.value());
				break;

			case '\\': ++position; break;

			case '!': {
				if (auto result = stack.template get<std::size_t>(); not result) [[unlikely]]
					return std::unexpected{result.error()};
				else
					auto _ = stack.set<std::size_t>(not result.value());
				break;
			}

			case '?': {
				if (auto condition = stack.template get<std::size_t>(sizeof(std::size_t)); not condition) [[unlikely]]
					return std::unexpected{condition.error()};
				else if (auto newPosition = stack.template pop<std::size_t>(); not newPosition) [[unlikely]]
					return std::unexpected{newPosition.error()};
				else if (not condition.value())
					position = newPosition.value();
				auto _ = stack.drop(sizeof(std::size_t));
				break;
			}

			case 'X': return {};

			case '+': {
				if (auto lhs = stack.template pop<std::size_t>(); not lhs) [[unlikely]]
					return std::unexpected{lhs.error()};
				else if (auto rhs = stack.template get<std::size_t>(); not rhs) [[unlikely]]
					return std::unexpected{rhs.error()};
				else
					auto _ = stack.set(lhs.value() + rhs.value());
				break;
			}

			case '-': {
				if (auto lhs = stack.template pop<std::size_t>(); not lhs) [[unlikely]]
					return std::unexpected{lhs.error()};
				else if (auto rhs = stack.template get<std::size_t>(); not rhs) [[unlikely]]
					return std::unexpected{rhs.error()};
				else
					auto _ = stack.set(lhs.value() - rhs.value());
				break;
			}

			case ',': stack.dump(); break;

			case '\'': { auto _ = stack.set(source[++position]); break; }

			default:
				if (instruction >= '0' and instruction <= '9')
				{
					if (auto result = stack.template get<std::size_t>(); not result) [[unlikely]]
						return std::unexpected{result.error()};
					else
						auto _ = stack.set(result.value() * 10 + static_cast<std::size_t>(instruction - '0'));
				}
				break;
			}

		return {};
	}
}