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

1 files changed, 100 insertions, 0 deletions

diff --git a/include/openvic-dataloader/detail/CallbackOStream.hpp b/include/openvic-dataloader/detail/CallbackOStream.hpp
new file mode 100644
index 0000000..641d53f
--- /dev/null
+++ b/include/openvic-dataloader/detail/CallbackOStream.hpp
@@ -0,0 +1,100 @@
+#pragma once
+
+#include <cstring>
+#include <functional>
+#include <ostream>
+#include <type_traits>
+
+namespace ovdl::detail {
+	template<typename Callback, class CHAR_T, class traits = std::char_traits<CHAR_T>>
+	class BasicCallbackStreamBuffer : public std::basic_streambuf<CHAR_T, traits> {
+	public:
+		using base_type = std::basic_streambuf<CHAR_T, traits>;
+		using callback_type = Callback;
+		using char_type = typename base_type::char_type;
+		using int_type = typename base_type::int_type;
+
+		BasicCallbackStreamBuffer(Callback cb, void* user_data = nullptr)
+			: _callback(cb),
+			  _user_data(user_data) {}
+
+	protected:
+		std::streamsize xsputn(const char_type* s, std::streamsize n) override {
+			if constexpr (std::is_same_v<void, typename decltype(std::function { _callback })::result_type>) {
+				_callback(s, n, _user_data);
+				return n;
+			} else {
+				return _callback(s, n, _user_data); // returns the number of characters successfully written.
+			}
+		};
+
+		int_type overflow(int_type ch) override {
+			if constexpr (std::is_same_v<void, typename decltype(std::function { _callback })::result_type>) {
+				_callback(&ch, 1, _user_data);
+				return 1;
+			} else {
+				return _callback(&ch, 1, _user_data); // returns the number of characters successfully written.
+			}
+		}
+
+	private:
+		Callback _callback;
+		void* _user_data;
+	};
+
+	template<typename Callback>
+	class CallbackStreamBuffer : public BasicCallbackStreamBuffer<Callback, char> {
+	public:
+		using base_type = BasicCallbackStreamBuffer<Callback, char>;
+		using callback_type = Callback;
+		using char_type = typename base_type::char_type;
+		using int_type = typename base_type::int_type;
+
+		CallbackStreamBuffer(Callback cb, void* user_data = nullptr) : base_type(cb, user_data) {}
+	};
+
+	template<typename Callback>
+	class CallbackWStreamBuffer : public BasicCallbackStreamBuffer<Callback, wchar_t> {
+	public:
+		using base_type = BasicCallbackStreamBuffer<Callback, wchar_t>;
+		using callback_type = Callback;
+		using char_type = typename base_type::char_type;
+		using int_type = typename base_type::int_type;
+
+		CallbackWStreamBuffer(Callback cb, void* user_data = nullptr) : base_type(cb, user_data) {}
+	};
+
+	template<typename Callback, class CHAR_T, class traits = std::char_traits<CHAR_T>>
+	class BasicCallbackStream : public std::basic_ostream<CHAR_T, traits> {
+	public:
+		using base_type = std::basic_ostream<CHAR_T, traits>;
+
+		BasicCallbackStream(Callback cb, void* user_data = nullptr)
+			: m_sbuf(cb, user_data),
+			  std::basic_ios<CHAR_T, traits>(&m_sbuf),
+			  std::basic_ostream<CHAR_T, traits>(&m_sbuf) {
+			std::basic_ios<CHAR_T, traits>::init(&m_sbuf);
+		}
+
+	private:
+		BasicCallbackStreamBuffer<Callback, CHAR_T, traits> m_sbuf;
+	};
+
+	template<typename Callback>
+	class CallbackStream : public BasicCallbackStream<Callback, char> {
+	public:
+		using base_type = BasicCallbackStream<Callback, char>;
+
+		CallbackStream(Callback cb, void* user_data = nullptr) : base_type(cb, user_data) {
+		}
+	};
+
+	template<typename Callback>
+	class CallbackWStream : public BasicCallbackStream<Callback, wchar_t> {
+	public:
+		using base_type = BasicCallbackStream<Callback, wchar_t>;
+
+		CallbackWStream(Callback cb, void* user_data = nullptr) : base_type(cb, user_data) {
+		}
+	};
+}
\ No newline at end of file