Merge pull request #7 from OpenVicProject/dataloading-event-and-functions

1 files changed, 224 insertions, 0 deletions

diff --git a/src/openvic-dataloader/v2script/Parser.cpp b/src/openvic-dataloader/v2script/Parser.cpp
new file mode 100644
index 0000000..07d6455
--- /dev/null
+++ b/src/openvic-dataloader/v2script/Parser.cpp
@@ -0,0 +1,224 @@
+#include "openvic-dataloader/v2script/Parser.hpp"
+
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <openvic-dataloader/ParseError.hpp>
+#include <openvic-dataloader/ParseWarning.hpp>
+#include <openvic-dataloader/detail/Concepts.hpp>
+#include <openvic-dataloader/v2script/AbstractSyntaxTree.hpp>
+
+#include <lexy/action/parse.hpp>
+#include <lexy/encoding.hpp>
+#include <lexy/input/buffer.hpp>
+#include <lexy/input/file.hpp>
+#include <lexy/lexeme.hpp>
+#include <lexy/visualize.hpp>
+
+#include "SimpleGrammar.hpp"
+#include "detail/BasicBufferHandler.hpp"
+#include "detail/DetectUtf8.hpp"
+#include "detail/Errors.hpp"
+#include "detail/LexyReportError.hpp"
+#include "detail/NullBuff.hpp"
+#include "detail/OStreamOutputIterator.hpp"
+#include "detail/Warnings.hpp"
+#include "v2script/DecisionGrammar.hpp"
+#include "v2script/EventGrammar.hpp"
+
+using namespace ovdl;
+using namespace ovdl::v2script;
+
+///	BufferHandler ///
+
+class Parser::BufferHandler final : public detail::BasicBufferHandler<> {
+public:
+	constexpr bool is_exclusive_utf8() const {
+		return detail::is_utf8_no_ascii(_buffer);
+	}
+
+	template<typename Node, typename ErrorCallback>
+	std::optional<std::vector<ParseError>> parse(const ErrorCallback& callback) {
+		auto result = lexy::parse<Node>(_buffer, callback);
+		if (!result) {
+			return result.errors();
+		}
+		// This is mighty frustrating
+		_root = std::unique_ptr<ast::Node>(result.value());
+		return std::nullopt;
+	}
+
+	std::unique_ptr<ast::Node>& get_root() {
+		return _root;
+	}
+
+private:
+	std::unique_ptr<ast::Node> _root;
+};
+
+/// BufferHandler ///
+
+Parser::Parser()
+	: _buffer_handler(std::make_unique<BufferHandler>()) {
+	set_error_log_to_stderr();
+}
+
+Parser::Parser(Parser&&) = default;
+Parser& Parser::operator=(Parser&&) = default;
+Parser::~Parser() = default;
+
+Parser Parser::from_buffer(const char* data, std::size_t size) {
+	Parser result;
+	return std::move(result.load_from_buffer(data, size));
+}
+
+Parser Parser::from_buffer(const char* start, const char* end) {
+	Parser result;
+	return std::move(result.load_from_buffer(start, end));
+}
+
+Parser Parser::from_string(const std::string_view string) {
+	Parser result;
+	return std::move(result.load_from_string(string));
+}
+
+Parser Parser::from_file(const char* path) {
+	Parser result;
+	return std::move(result.load_from_file(path));
+}
+
+Parser Parser::from_file(const std::filesystem::path& path) {
+	Parser result;
+	return std::move(result.load_from_file(path));
+}
+
+///
+/// @brief Executes a function on _buffer_handler that is expected to load a buffer
+///
+/// Expected Use:
+/// @code {.cpp}
+///	_run_load_func(&BufferHandler::<load_function>, <arguments>);
+/// @endcode
+///
+/// @tparam Type
+/// @tparam Args
+/// @param func
+/// @param args
+///
+template<typename... Args>
+constexpr void Parser::_run_load_func(detail::LoadCallback<BufferHandler, Args...> auto func, Args... args) {
+	_warnings.clear();
+	_errors.clear();
+	_has_fatal_error = false;
+	if (auto error = func(_buffer_handler.get(), std::forward<Args>(args)...); error) {
+		_has_fatal_error = error.value().type == ParseError::Type::Fatal;
+		_errors.push_back(error.value());
+		_error_stream.get() << "Error: " << _errors.back().message << '\n';
+	}
+}
+
+constexpr Parser& Parser::load_from_buffer(const char* data, std::size_t size) {
+	// Type can't be deduced?
+	_run_load_func(std::mem_fn(&BufferHandler::load_buffer_size), data, size);
+	return *this;
+}
+
+constexpr Parser& Parser::load_from_buffer(const char* start, const char* end) {
+	// Type can't be deduced?
+	_run_load_func(std::mem_fn(&BufferHandler::load_buffer), start, end);
+	return *this;
+}
+
+constexpr Parser& Parser::load_from_string(const std::string_view string) {
+	return load_from_buffer(string.data(), string.size());
+}
+
+constexpr Parser& Parser::load_from_file(const char* path) {
+	_file_path = path;
+	// Type can be deduced??
+	_run_load_func(std::mem_fn(&BufferHandler::load_file), path);
+	return *this;
+}
+
+Parser& Parser::load_from_file(const std::filesystem::path& path) {
+	return load_from_file(path.string().c_str());
+}
+
+constexpr Parser& Parser::load_from_file(const detail::Has_c_str auto& path) {
+	return load_from_file(path.c_str());
+}
+
+bool Parser::simple_parse() {
+	if (!_buffer_handler->is_valid()) {
+		return false;
+	}
+
+	if (_buffer_handler->is_exclusive_utf8()) {
+		_warnings.push_back(warnings::make_utf8_warning(_file_path));
+	}
+
+	auto errors = _buffer_handler->parse<grammar::File>(ovdl::detail::ReporError.path(_file_path).to(detail::OStreamOutputIterator { _error_stream }));
+	if (errors) {
+		_errors.reserve(errors->size());
+		for (auto& err : errors.value()) {
+			_has_fatal_error |= err.type == ParseError::Type::Fatal;
+			_errors.push_back(err);
+		}
+		return false;
+	}
+	_file_node.reset(static_cast<ast::FileNode*>(_buffer_handler->get_root().release()));
+	return true;
+}
+
+bool Parser::event_parse() {
+	if (!_buffer_handler->is_valid()) {
+		return false;
+	}
+
+	if (_buffer_handler->is_exclusive_utf8()) {
+		_warnings.push_back(warnings::make_utf8_warning(_file_path));
+	}
+
+	auto errors = _buffer_handler->parse<grammar::EventFile>(ovdl::detail::ReporError.path(_file_path).to(detail::OStreamOutputIterator { _error_stream }));
+	if (errors) {
+		_errors.reserve(errors->size());
+		for (auto& err : errors.value()) {
+			_has_fatal_error |= err.type == ParseError::Type::Fatal;
+			_errors.push_back(err);
+		}
+		return false;
+	}
+	_file_node.reset(static_cast<ast::FileNode*>(_buffer_handler->get_root().release()));
+	return true;
+}
+
+bool Parser::decision_parse() {
+	if (!_buffer_handler->is_valid()) {
+		return false;
+	}
+
+	if (_buffer_handler->is_exclusive_utf8()) {
+		_warnings.push_back(warnings::make_utf8_warning(_file_path));
+	}
+
+	auto errors = _buffer_handler->parse<grammar::DecisionFile>(ovdl::detail::ReporError.path(_file_path).to(detail::OStreamOutputIterator { _error_stream }));
+	if (errors) {
+		_errors.reserve(errors->size());
+		for (auto& err : errors.value()) {
+			_has_fatal_error |= err.type == ParseError::Type::Fatal;
+			_errors.push_back(err);
+		}
+		return false;
+	}
+	_file_node.reset(static_cast<ast::FileNode*>(_buffer_handler->get_root().release()));
+	return true;
+}
+
+const FileNode* Parser::get_file_node() const {
+	return _file_node.get();
+}
\ No newline at end of file