aboutsummaryrefslogtreecommitdiff
path: root/src/openvic-dataloader/v2script/Parser.cpp
diff options
context:
space:
mode:
author Spartan322 <Megacake1234@gmail.com>2023-07-28 06:52:00 +0200
committer Spartan322 <Megacake1234@gmail.com>2023-09-02 14:28:21 +0200
commit7440a5d1433eec4bf87e3723022db187e7f61b1a (patch)
tree2bb062c320fa2227b18956617b94d0e8800420d8 /src/openvic-dataloader/v2script/Parser.cpp
parente941573f47fb867ff75c8a2cf78302b754ffbeee (diff)
Rework Grammar and Parser
Add proper headless binary construction: Includes basic validation Add Error and Warning structs to Parser Add FileNode pointer getter to Parser Change all `char8_t*` and `const char8_t` to `const char*` in Parser Add Parser move operators and Parser deconstructor Add BufferHandler PIMPL object to Parser Add UTF-8 file Warning to v2script Add proper Grammar value retrieval Add AbstractSyntaxTree for v2script data parser: Has compile-time embedded type information accessible at compile-time and runtime Has Tab-based print functionality Fix wrong environment reference for headless construction in SConstruct Add error retrieval Add BasicCallbackOStreamBuffer for callback streaming Add CallbackStreamBuffer for char Add CallbackWStreamBuffer for wchar_t Add BasicCallbackStream Add CallbackStream for char Add CallbackWStream for wchar_t Add grammar for events and decisions Add event_parse to Parser Add decision_parse to Parser Add .clang-format Ignore dirty lexy module Add CSV parser and grammar: Creates std::vector<csv::LineObject> for a list of lines Add BasicParser and BasicBufferHandler to reduce code reduplication
Diffstat (limited to 'src/openvic-dataloader/v2script/Parser.cpp')
-rw-r--r--src/openvic-dataloader/v2script/Parser.cpp224
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