Add `deps/dryad` -> https://github.com/Spartan322/dryadadd/dryad

Add `deps/fmt` -> https://github.com/fmtlib/fmt
Add `deps/range-v3` -> https://github.com/ericniebler/range-v3

Improve parser error and warning support
Update .clang-format
Update `deps/SCsub`

12 files changed, 559 insertions, 217 deletions

diff --git a/src/openvic-dataloader/detail/BasicBufferHandler.hpp b/src/openvic-dataloader/detail/BasicBufferHandler.hpp
deleted file mode 100644
index f26544b..0000000
--- a/src/openvic-dataloader/detail/BasicBufferHandler.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#pragma once
-
-#include <optional>
-
-#include <openvic-dataloader/ParseError.hpp>
-#include <openvic-dataloader/detail/OptionalConstexpr.hpp>
-
-#include <lexy/encoding.hpp>
-#include <lexy/input/buffer.hpp>
-#include <lexy/input/file.hpp>
-
-#include "detail/Errors.hpp"
-
-namespace ovdl::detail {
-	template<typename Encoding = lexy::default_encoding, typename MemoryResource = void>
-	class BasicBufferHandler {
-	public:
-		using encoding_type = Encoding;
-
-		OVDL_OPTIONAL_CONSTEXPR bool is_valid() const {
-			return _buffer.data() != nullptr;
-		}
-
-		OVDL_OPTIONAL_CONSTEXPR std::optional<ovdl::ParseError> load_buffer_size(const char* data, std::size_t size) {
-			_buffer = lexy::buffer<Encoding, MemoryResource>(data, size);
-			return std::nullopt;
-		}
-
-		OVDL_OPTIONAL_CONSTEXPR std::optional<ovdl::ParseError> load_buffer(const char* start, const char* end) {
-			_buffer = lexy::buffer<Encoding, MemoryResource>(start, end);
-			return std::nullopt;
-		}
-
-		std::optional<ovdl::ParseError> load_file(const char* path) {
-			auto file = lexy::read_file<Encoding, lexy::encoding_endianness::bom, MemoryResource>(path);
-			if (!file) {
-				return ovdl::errors::make_no_file_error(path);
-			}
-
-			_buffer = file.buffer();
-			return std::nullopt;
-		}
-
-		const auto& get_buffer() const {
-			return _buffer;
-		}
-
-	protected:
-		lexy::buffer<Encoding, MemoryResource> _buffer;
-	};
-}
\ No newline at end of file
diff --git a/src/openvic-dataloader/detail/BufferError.hpp b/src/openvic-dataloader/detail/BufferError.hpp
new file mode 100644
index 0000000..1fbb0f4
--- /dev/null
+++ b/src/openvic-dataloader/detail/BufferError.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <cstdint>
+
+namespace ovdl::detail {
+	enum class buffer_error : std::uint8_t {
+		success,
+		/// An internal OS error, such as failure to read from the file.
+		os_error,
+		/// The file was not found.
+		file_not_found,
+		/// The file cannot be opened.
+		permission_denied,
+		/// The buffer failed to handle the data
+		buffer_is_null
+	};
+}
\ No newline at end of file
diff --git a/src/openvic-dataloader/detail/DetectUtf8.hpp b/src/openvic-dataloader/detail/DetectUtf8.hpp
index 2045b3c..e9d0350 100644
--- a/src/openvic-dataloader/detail/DetectUtf8.hpp
+++ b/src/openvic-dataloader/detail/DetectUtf8.hpp
@@ -3,7 +3,7 @@
 #include <lexy/action/match.hpp>
 #include <lexy/dsl.hpp>
 
-#include "detail/LexyLitRange.hpp"
+#include "detail/dsl.hpp"
 
 namespace ovdl::detail {
 	namespace detect_utf8 {
@@ -18,15 +18,15 @@ namespace ovdl::detail {
 				constexpr auto is_not_ascii_flag = lexy::dsl::context_flag<DetectUtf8>;
 
 				// & 0b10000000 == 0b00000000
-				constexpr auto ascii_values = lexydsl::make_range<0b00000000, 0b01111111>();
+				constexpr auto ascii_values = dsl::make_range<0b00000000, 0b01111111>();
 				// & 0b11100000 == 0b11000000
-				constexpr auto two_byte = lexydsl::make_range<0b11000000, 0b11011111>();
+				constexpr auto two_byte = dsl::make_range<0b11000000, 0b11011111>();
 				// & 0b11110000 == 0b11100000
-				constexpr auto three_byte = lexydsl::make_range<0b11100000, 0b11101111>();
+				constexpr auto three_byte = dsl::make_range<0b11100000, 0b11101111>();
 				// & 0b11111000 == 0b11110000
-				constexpr auto four_byte = lexydsl::make_range<0b11110000, 0b11110111>();
+				constexpr auto four_byte = dsl::make_range<0b11110000, 0b11110111>();
 				// & 0b11000000 == 0b10000000
-				constexpr auto check_bytes = lexydsl::make_range<0b10000000, 0b10111111>();
+				constexpr auto check_bytes = dsl::make_range<0b10000000, 0b10111111>();
 
 				constexpr auto utf8_check =
 					((four_byte >> lexy::dsl::times<3>(check_bytes)) |
diff --git a/src/openvic-dataloader/detail/LexyLitRange.hpp b/src/openvic-dataloader/detail/LexyLitRange.hpp
deleted file mode 100644
index a6761a8..0000000
--- a/src/openvic-dataloader/detail/LexyLitRange.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include <lexy/dsl/literal.hpp>
-
-namespace ovdl::detail::lexydsl {
-	template<unsigned char LOW, unsigned char HIGH>
-	consteval auto make_range() {
-		if constexpr (LOW == HIGH) {
-			return lexy::dsl::lit_c<LOW>;
-		} else if constexpr (LOW == (HIGH - 1)) {
-			return lexy::dsl::lit_c<LOW> / lexy::dsl::lit_c<HIGH>;
-		} else {
-			return lexy::dsl::lit_c<LOW> / make_range<LOW + 1, HIGH>();
-		}
-	}
-}
\ No newline at end of file
diff --git a/src/openvic-dataloader/detail/LexyReportError.hpp b/src/openvic-dataloader/detail/LexyReportError.hpp
deleted file mode 100644
index 213090b..0000000
--- a/src/openvic-dataloader/detail/LexyReportError.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <sstream>
-#include <utility>
-#include <vector>
-
-#include <openvic-dataloader/ParseData.hpp>
-#include <openvic-dataloader/ParseError.hpp>
-#include <openvic-dataloader/detail/Concepts.hpp>
-
-#include <lexy/input_location.hpp>
-#include <lexy/visualize.hpp>
-
-#include <lexy_ext/report_error.hpp>
-
-namespace ovdl::detail {
-	template<typename OutputIterator>
-	struct _ReportError {
-		OutputIterator _iter;
-		lexy::visualization_options _opts;
-		const char* _path;
-
-		struct _sink {
-			OutputIterator _iter;
-			lexy::visualization_options _opts;
-			const char* _path;
-			std::size_t _count;
-			std::vector<ParseError> _errors;
-
-			using return_type = std::vector<ParseError>;
-
-			template<typename Input, typename Reader, typename Tag>
-			void operator()(const lexy::error_context<Input>& context, const lexy::error<Reader, Tag>& error) {
-				_iter = lexy_ext::_detail::write_error(_iter, context, error, _opts, _path);
-				++_count;
-
-				// Convert the context location and error location into line/column information.
-				auto context_location = lexy::get_input_location(context.input(), context.position());
-				auto location = lexy::get_input_location(context.input(), error.position(), context_location.anchor());
-
-				std::basic_stringstream<typename Reader::encoding::char_type> message;
-
-				// Write the main annotation.
-				if constexpr (std::is_same_v<Tag, lexy::expected_literal>) {
-					auto string = lexy::_detail::make_literal_lexeme<typename Reader::encoding>(error.string(), error.length());
-
-					message << "expected '" << string.data() << '\'';
-				} else if constexpr (std::is_same_v<Tag, lexy::expected_keyword>) {
-					auto string = lexy::_detail::make_literal_lexeme<typename Reader::encoding>(error.string(), error.length());
-
-					message << "expected keyword '" << string.data() << '\'';
-				} else if constexpr (std::is_same_v<Tag, lexy::expected_char_class>) {
-					message << "expected " << error.name();
-				} else {
-					message << error.message();
-				}
-
-				_errors.push_back(
-					ParseError {
-						ParseError::Type::Fatal, // TODO: distinguish recoverable errors from fatal errors
-						std::move(message.str()),
-						0, // TODO: implement proper error codes
-						ParseData {
-							context.production(),
-							context_location.line_nr(),
-							context_location.column_nr(),
-						},
-						location.line_nr(),
-						location.column_nr(),
-					});
-			}
-
-			return_type finish() && {
-				if (_count != 0)
-					*_iter++ = '\n';
-				return _errors;
-			}
-		};
-		constexpr auto sink() const {
-			return _sink { _iter, _opts, _path, 0 };
-		}
-
-		/// Specifies a path that will be printed alongside the diagnostic.
-		constexpr _ReportError path(const char* path) const {
-			return { _iter, _opts, path };
-		}
-
-		constexpr _ReportError path(const detail::Has_c_str auto& path_object) const {
-			return path(path_object.c_str());
-		}
-
-		/// Specifies an output iterator where the errors are written to.
-		template<typename OI>
-		constexpr _ReportError<OI> to(OI out) const {
-			return { out, _opts, _path };
-		}
-
-		/// Overrides visualization options.
-		constexpr _ReportError opts(lexy::visualization_options opts) const {
-			return { _iter, opts, _path };
-		}
-	};
-
-	constexpr auto ReporError = _ReportError<lexy::stderr_output_iterator> {};
-}
\ No newline at end of file
diff --git a/src/openvic-dataloader/detail/NullBuff.hpp b/src/openvic-dataloader/detail/NullBuff.hpp
index baf9e1b..e5c6f4a 100644
--- a/src/openvic-dataloader/detail/NullBuff.hpp
+++ b/src/openvic-dataloader/detail/NullBuff.hpp
@@ -22,9 +22,9 @@ namespace ovdl::detail {
 		basic_nullbuf<cT, traits> m_sbuf;
 	};
 
-	typedef basic_onullstream<char> onullstream;
-	typedef basic_onullstream<wchar_t> wonullstream;
+	using onullstream = basic_onullstream<char>;
+	using wonullstream = basic_onullstream<wchar_t>;
 
-	inline onullstream cnull;
-	inline onullstream wcnull;
+	static inline onullstream cnull;
+	static inline onullstream wcnull;
 }
\ No newline at end of file
diff --git a/src/openvic-dataloader/detail/OStreamOutputIterator.hpp b/src/openvic-dataloader/detail/OStreamOutputIterator.hpp
deleted file mode 100644
index 81f6c89..0000000
--- a/src/openvic-dataloader/detail/OStreamOutputIterator.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include <ostream>
-
-namespace ovdl::detail {
-	struct OStreamOutputIterator {
-		std::reference_wrapper<std::ostream> _stream;
-
-		auto operator*() const noexcept {
-			return *this;
-		}
-		auto operator++(int) const noexcept {
-			return *this;
-		}
-
-		OStreamOutputIterator& operator=(char c) {
-			_stream.get().put(c);
-			return *this;
-		}
-	};
-}
\ No newline at end of file
diff --git a/src/openvic-dataloader/detail/ParseHandler.hpp b/src/openvic-dataloader/detail/ParseHandler.hpp
new file mode 100644
index 0000000..fbec0d7
--- /dev/null
+++ b/src/openvic-dataloader/detail/ParseHandler.hpp
@@ -0,0 +1,145 @@
+#pragma once
+
+#include <utility>
+
+#include <openvic-dataloader/ParseState.hpp>
+#include <openvic-dataloader/detail/utility/Concepts.hpp>
+
+#include <lexy/encoding.hpp>
+#include <lexy/input/buffer.hpp>
+#include <lexy/input/file.hpp>
+
+#include "detail/BufferError.hpp"
+
+namespace ovdl::detail {
+	template<typename Derived>
+	struct ParseHandler {
+		std::string make_error_from(buffer_error error) {
+			switch (error) {
+				using enum ovdl::detail::buffer_error;
+				case buffer_is_null:
+					return "Buffer could not be loaded.";
+				case os_error:
+					return "OS file error.";
+				case file_not_found:
+					return "File not found.";
+				case permission_denied:
+					return "Read Permission denied.";
+				default:
+					return "";
+			}
+		}
+
+		template<typename... Args>
+		constexpr void _run_load_func(detail::LoadCallback<Derived, Args...> auto func, Args... args);
+	};
+
+	template<IsFileParseState ParseState, typename MemoryResource = void>
+	struct BasicFileParseHandler : ParseHandler<BasicFileParseHandler<ParseState, MemoryResource>> {
+		using parse_state_type = ParseState;
+		using encoding_type = typename parse_state_type::file_type::encoding_type;
+
+		constexpr bool is_valid() const {
+			if (!_parse_state) return false;
+			return buffer().data() != nullptr;
+		}
+
+		constexpr buffer_error load_buffer_size(const char* data, std::size_t size) {
+			lexy::buffer<encoding_type, MemoryResource> buffer(data, size);
+			if (buffer.data() == nullptr) return buffer_error::buffer_is_null;
+			_parse_state.reset(new parse_state_type { std::move(buffer) });
+			return is_valid() ? buffer_error::success : buffer_error::buffer_is_null;
+		}
+
+		constexpr buffer_error load_buffer(const char* start, const char* end) {
+			lexy::buffer<encoding_type, MemoryResource> buffer(start, end);
+			if (buffer.data() == nullptr) return buffer_error::buffer_is_null;
+			_parse_state.reset(new parse_state_type { std::move(buffer) });
+			return is_valid() ? buffer_error::success : buffer_error::buffer_is_null;
+		}
+
+		buffer_error load_file(const char* path) {
+			lexy::read_file_result file = lexy::read_file<encoding_type, lexy::encoding_endianness::bom, MemoryResource>(path);
+			if (!file) {
+				_parse_state.reset(new parse_state_type { path, lexy::buffer<typename parse_state_type::file_type::encoding_type>() });
+				return ovdl::detail::from_underlying<buffer_error>(ovdl::detail::to_underlying(file.error()));
+			}
+			_parse_state.reset(new parse_state_type { path, std::move(file).buffer() });
+			return is_valid() ? buffer_error::success : buffer_error::buffer_is_null;
+		}
+
+		const char* path() const {
+			if (!_parse_state) return "";
+			return _parse_state->file().path();
+		}
+
+		parse_state_type& parse_state() {
+			return *_parse_state;
+		}
+
+		const parse_state_type& parse_state() const {
+			return *_parse_state;
+		}
+
+		constexpr const auto& buffer() const {
+			return _parse_state->file().buffer();
+		}
+
+	protected:
+		std::unique_ptr<parse_state_type> _parse_state;
+	};
+
+	template<IsParseState ParseState, typename MemoryResource = void>
+	struct BasicStateParseHandler : ParseHandler<BasicStateParseHandler<ParseState, MemoryResource>> {
+		using parse_state_type = ParseState;
+		using encoding_type = typename parse_state_type::ast_type::file_type::encoding_type;
+
+		constexpr bool is_valid() const {
+			if (!_parse_state) return false;
+			return buffer().data() != nullptr;
+		}
+
+		constexpr buffer_error load_buffer_size(const char* data, std::size_t size) {
+			lexy::buffer<encoding_type, MemoryResource> buffer(data, size);
+			_parse_state.reset(new parse_state_type { std::move(buffer) });
+			return is_valid() ? buffer_error::success : buffer_error::buffer_is_null;
+		}
+
+		constexpr buffer_error load_buffer(const char* start, const char* end) {
+			lexy::buffer<encoding_type, MemoryResource> buffer(start, end);
+			_parse_state.reset(new parse_state_type { std::move(buffer) });
+			return is_valid() ? buffer_error::success : buffer_error::buffer_is_null;
+		}
+
+		buffer_error load_file(const char* path) {
+			lexy::read_file_result file = lexy::read_file<encoding_type, lexy::encoding_endianness::bom, MemoryResource>(path);
+			if (!file) {
+				_parse_state.reset(new parse_state_type { path, lexy::buffer<typename parse_state_type::ast_type::file_type::encoding_type>() });
+				return ovdl::detail::from_underlying<buffer_error>(ovdl::detail::to_underlying(file.error()));
+			}
+
+			_parse_state.reset(new parse_state_type { path, std::move(file).buffer() });
+			return is_valid() ? buffer_error::success : buffer_error::buffer_is_null;
+		}
+
+		const char* path() const {
+			if (!_parse_state) return "";
+			return _parse_state->ast().file().path();
+		}
+
+		parse_state_type& parse_state() {
+			return *_parse_state;
+		}
+
+		const parse_state_type& parse_state() const {
+			return *_parse_state;
+		}
+
+		constexpr const auto& buffer() const {
+			return _parse_state->ast().file().buffer();
+		}
+
+	protected:
+		std::unique_ptr<parse_state_type> _parse_state;
+	};
+}
\ No newline at end of file
diff --git a/src/openvic-dataloader/detail/BasicParser.cpp b/src/openvic-dataloader/detail/Parser.cpp
index 212bf00..fd87687 100644
--- a/src/openvic-dataloader/detail/BasicParser.cpp
+++ b/src/openvic-dataloader/detail/Parser.cpp
@@ -1,7 +1,7 @@
 #include <iostream>
 #include <ostream>
 
-#include <openvic-dataloader/detail/BasicParser.hpp>
+#include <openvic-dataloader/Parser.hpp>
 
 #include "detail/NullBuff.hpp"
 
@@ -27,7 +27,7 @@ void BasicParser::set_error_log_to(std::basic_ostream<char>& stream) {
 }
 
 bool BasicParser::has_error() const {
-	return !_errors.empty();
+	return _has_error;
 }
 
 bool BasicParser::has_fatal_error() const {
@@ -35,15 +35,7 @@ bool BasicParser::has_fatal_error() const {
 }
 
 bool BasicParser::has_warning() const {
-	return !_warnings.empty();
-}
-
-const std::vector<ovdl::ParseError>& BasicParser::get_errors() const {
-	return _errors;
-}
-
-const std::vector<ovdl::ParseWarning>& BasicParser::get_warnings() const {
-	return _warnings;
+	return _has_warning;
 }
 
 std::string_view BasicParser::get_file_path() const {
diff --git a/src/openvic-dataloader/detail/StringLiteral.hpp b/src/openvic-dataloader/detail/StringLiteral.hpp
new file mode 100644
index 0000000..985b087
--- /dev/null
+++ b/src/openvic-dataloader/detail/StringLiteral.hpp
@@ -0,0 +1,232 @@
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <type_traits>
+
+#include <lexy/_detail/config.hpp>
+#include <lexy/_detail/integer_sequence.hpp>
+#include <lexy/dsl/identifier.hpp>
+
+namespace ovdl::detail {
+
+	template<std::size_t N, typename CharT>
+	struct string_literal;
+
+	struct _string_literal {
+	protected:
+		static constexpr auto _to_string(const auto& input) { return string_literal(input); }
+		static constexpr auto _concat(const auto&... input) { return string_literal(_to_string(input)...); }
+	};
+
+	template<std::size_t N, typename CharT = char>
+	struct string_literal : _string_literal {
+		using value_type = CharT;
+		using pointer = value_type*;
+		using const_pointer = const value_type*;
+		using reference = value_type&;
+		using const_reference = const value_type&;
+		using size_type = std::size_t;
+		using difference_type = std::ptrdiff_t;
+		using traits_type = std::char_traits<value_type>;
+
+		static constexpr size_type npos = size_type(-1);
+
+		static constexpr auto size = std::integral_constant<std::size_t, N - 1> {};
+		static constexpr auto length = size;
+
+		value_type _data[N];
+
+		constexpr string_literal() noexcept = default;
+
+		constexpr string_literal(const value_type (&literal)[N]) noexcept {
+			for (auto i = 0u; i != N; i++)
+				_data[i] = literal[i];
+		}
+
+		constexpr string_literal(value_type c) noexcept : _data {} {
+			_data[0] = c;
+		}
+
+		constexpr auto begin() noexcept { return std::begin(_data); }
+		constexpr auto end() noexcept { return std::end(_data); }
+		constexpr auto cbegin() const noexcept { return std::cbegin(_data); }
+		constexpr auto cend() const noexcept { return std::cend(_data); }
+		constexpr auto rbegin() noexcept { return std::rbegin(_data); }
+		constexpr auto rend() noexcept { return std::rend(_data); }
+		constexpr auto crbegin() const noexcept { return std::crbegin(_data); }
+		constexpr auto crend() const noexcept { return std::crend(_data); }
+
+		constexpr auto front() const noexcept { return as_string_view().front(); }
+		constexpr auto back() const noexcept { return as_string_view().back(); }
+		constexpr auto at(size_type pos) const { return as_string_view().at(pos); }
+
+		constexpr auto operator[](size_type pos) const noexcept { return as_string_view()[pos]; }
+
+		constexpr bool empty() const { return as_string_view().empty(); }
+
+		template<size_type N2>
+		constexpr bool operator==(const string_literal<N2, value_type>& other) const {
+			return as_string_view() == other.as_string_view();
+		}
+
+		constexpr bool starts_with(std::basic_string_view<value_type> sv) const noexcept { return as_string_view().starts_with(sv); }
+		constexpr bool starts_with(value_type ch) const noexcept { return as_string_view().starts_with(ch); }
+		constexpr bool starts_with(const value_type* s) const { return as_string_view().starts_with(s); }
+
+		template<size_type N2>
+		constexpr bool starts_with(const string_literal<N2, value_type>& other) const {
+			return starts_with(other.as_string_view());
+		}
+
+		constexpr bool ends_with(std::basic_string_view<value_type> sv) const noexcept { return as_string_view().ends_with(sv); }
+		constexpr bool ends_with(value_type ch) const noexcept { return as_string_view().ends_with(ch); }
+		constexpr bool ends_with(const value_type* s) const { return as_string_view().ends_with(s); }
+
+		template<size_type N2>
+		constexpr bool ends_with(const string_literal<N2, value_type>& other) const {
+			return ends_with(other.as_string_view());
+		}
+
+		constexpr auto clear() const noexcept {
+			return string_literal<0, value_type> {};
+		}
+
+		constexpr auto push_back(value_type c) const noexcept {
+			return *this + string_literal { c };
+		}
+
+		constexpr auto pop_back() const noexcept {
+			string_literal<N - 1, value_type> result {};
+			for (auto i = 0u; i != N - 2; i++)
+				result._data[i] = _data[i];
+			return result;
+		}
+
+		template<size_type count>
+		constexpr auto append(value_type ch) const noexcept {
+			string_literal<N + count, value_type> result {};
+			for (auto i = 0u; i != N; i++)
+				result._data[i] = _data[i];
+
+			for (auto i = N; i != N + count; i++)
+				result._data[i] = ch;
+
+			return result;
+		}
+
+		template<size_type N2>
+		constexpr auto append(string_literal<N2, value_type> str) const noexcept {
+			return *this + str;
+		}
+
+		template<size_type N2>
+		constexpr auto append(const value_type (&literal)[N2]) const noexcept {
+			return *this + literal;
+		}
+
+		template<size_type pos = 0, size_type count = npos>
+		constexpr auto substr() const noexcept {
+			static_assert(pos <= N, "pos must be less than or equal to N");
+			constexpr size_type result_size = std::min(count - pos, N - pos);
+
+			string_literal<result_size, value_type> result {};
+			for (size_type i = 0u, i2 = pos; i != result_size; i++, i2++)
+				result._data[i] = _data[i2];
+			return result;
+		}
+
+		constexpr auto substr() const noexcept {
+			return substr<>();
+		}
+
+		constexpr std::string_view substr(size_type pos, size_type count = npos) const noexcept {
+			return as_string_view().substr(pos, count);
+		}
+
+		constexpr size_type find(std::string_view str, size_type pos = 0) const noexcept {
+			return as_string_view().find(str, pos);
+		}
+
+		template<size_type N2>
+		constexpr size_type find(const value_type (&literal)[N2], size_type pos = 0) const noexcept {
+			return as_string_view().find(literal, pos, N2 - 2);
+		}
+
+		constexpr size_type rfind(std::string_view str, size_type pos = 0) const noexcept {
+			return as_string_view().rfind(str, pos);
+		}
+
+		template<size_type N2>
+		constexpr size_type rfind(const value_type (&literal)[N2], size_type pos = 0) const noexcept {
+			return as_string_view().find(literal, pos, N2 - 2);
+		}
+
+		constexpr int compare(std::string_view str) const noexcept {
+			return as_string_view().compare(str);
+		}
+
+		template<size_type N2>
+		constexpr int compare(const value_type (&literal)[N2]) const noexcept {
+			return as_string_view().compare(0, N, literal, N2 - 2);
+		}
+
+		constexpr operator std::basic_string_view<value_type>() const& { return as_string_view(); }
+		constexpr operator std::basic_string_view<value_type>() const&& = delete;
+
+		constexpr std::basic_string_view<value_type> as_string_view() const& { return std::basic_string_view<value_type>(_data, size() - 1); }
+		constexpr std::basic_string_view<value_type> as_string_view() const&& = delete;
+
+		constexpr operator const value_type*() const& { return c_str(); }
+		constexpr operator const value_type*() const&& = delete;
+
+		constexpr const value_type* c_str() const& { return _data; }
+		constexpr const value_type* c_str() const&& = delete;
+
+		constexpr const value_type* data() const& { return _data; }
+		constexpr const value_type* data() const&& = delete;
+
+		template<size_type N2>
+		constexpr auto operator+(const string_literal<N2, value_type>& other) const noexcept {
+			string_literal<N + N2 - 1, value_type> result {};
+			for (size_type i = 0u; i != N; i++)
+				result._data[i] = _data[i];
+
+			for (size_type i = N - 1, i2 = 0; i2 != N2; i++, i2++)
+				result._data[i] = other._data[i2];
+			return result;
+		}
+
+		template<size_type N2>
+		constexpr auto operator+(const value_type (&rhs)[N2]) const noexcept {
+			return *this + _to_string(rhs);
+		}
+
+		template<size_type N2>
+		friend constexpr auto operator+(const value_type (&lhs)[N2], string_literal<N, value_type> rhs) noexcept {
+			return _to_string(lhs) + rhs;
+		}
+	};
+	template<std::size_t N, typename CharT = char>
+	string_literal(const CharT (&)[N]) -> string_literal<N, CharT>;
+
+	template<typename CharT = char>
+	string_literal(CharT) -> string_literal<1, CharT>;
+
+	template<template<typename C, C... Cs> typename T, string_literal Str, std::size_t... Idx>
+	auto _to_type_string(lexy::_detail::index_sequence<Idx...>) {
+		return T<typename decltype(Str)::value_type, Str._data[Idx]...> {};
+	}
+	template<template<typename C, C... Cs> typename T, string_literal Str>
+	using to_type_string = decltype(ovdl::detail::_to_type_string<T, Str>(lexy::_detail::make_index_sequence<decltype(Str)::size()> {}));
+}
+
+namespace ovdl::dsl {
+	template<ovdl::detail::string_literal Str, typename L, typename T, typename... R>
+	constexpr auto keyword(lexyd::_id<L, T, R...>) {
+		return ovdl::detail::to_type_string<lexyd::_keyword<lexyd::_id<L, T>>::template get, Str> {};
+	}
+}
\ No newline at end of file
diff --git a/src/openvic-dataloader/detail/Warnings.hpp b/src/openvic-dataloader/detail/Warnings.hpp
index 8fc09bd..ab718bc 100644
--- a/src/openvic-dataloader/detail/Warnings.hpp
+++ b/src/openvic-dataloader/detail/Warnings.hpp
@@ -5,7 +5,7 @@
 #include <openvic-dataloader/ParseWarning.hpp>
 
 namespace ovdl::v2script::warnings {
-	inline const ParseWarning make_utf8_warning(std::string_view file_path) {
+	inline const std::string make_utf8_warning(std::string_view file_path) {
 		constexpr std::string_view message_suffix = "This may cause problems. Prefer Windows-1252 encoding.";
 
 		std::string message;
@@ -15,7 +15,7 @@ namespace ovdl::v2script::warnings {
 			message = "File '" + std::string(file_path) + "' is a UTF-8 encoded file. " + std::string(message_suffix);
 		}
 
-		return ParseWarning { message, 1 };
+		return message;
 	}
 }
 
diff --git a/src/openvic-dataloader/detail/dsl.hpp b/src/openvic-dataloader/detail/dsl.hpp
new file mode 100644
index 0000000..9b544bc
--- /dev/null
+++ b/src/openvic-dataloader/detail/dsl.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <type_traits>
+
+#include <openvic-dataloader/NodeLocation.hpp>
+#include <openvic-dataloader/ParseState.hpp>
+
+#include <lexy/callback/adapter.hpp>
+#include <lexy/callback/bind.hpp>
+#include <lexy/callback/container.hpp>
+#include <lexy/callback/fold.hpp>
+#include <lexy/dsl.hpp>
+
+#include "detail/StringLiteral.hpp"
+
+namespace ovdl::dsl {
+	template<typename ReturnType, typename... Callback>
+	constexpr auto callback(Callback... cb) {
+		return lexy::bind(lexy::callback<ReturnType>(cb...), lexy::parse_state, lexy::values);
+	}
+
+	template<typename Sink>
+	constexpr auto sink(Sink sink) {
+		return lexy::bind_sink(sink, lexy::parse_state);
+	}
+
+	template<typename Container, typename Callback>
+	constexpr auto collect(Callback callback) {
+		return sink(lexy::collect<Container>(callback));
+	}
+
+	template<typename Callback>
+	constexpr auto collect(Callback callback) {
+		return sink(lexy::collect(callback));
+	}
+
+	template<IsParseState StateType, typename T>
+	constexpr auto construct = callback<T*>(
+		[](StateType& state, ovdl::NodeLocation loc, auto&& arg) {
+			if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, lexy::nullopt>)
+				return state.ast().template create<T>(loc);
+			else
+				return state.ast().template create<T>(loc, DRYAD_FWD(arg));
+		},
+		[](StateType& state, ovdl::NodeLocation loc, auto&&... args) {
+			return state.ast().template create<T>(loc, DRYAD_FWD(args)...);
+		});
+
+	template<IsParseState StateType, typename T, typename ListType, bool DisableEmpty = false>
+	constexpr auto construct_list = callback<T*>(
+		[](StateType& state, const char* begin, ListType&& arg, const char* end) {
+			return state.ast().template create<T>(NodeLocation::make_from(begin, end), DRYAD_FWD(arg));
+		},
+		[](StateType& state, const char* begin, lexy::nullopt, const char* end) {
+			return state.ast().template create<T>(NodeLocation::make_from(begin, end));
+		},
+		[](StateType& state, const char* begin, const char* end) {
+			return state.ast().template create<T>(NodeLocation::make_from(begin, end));
+		});
+
+	template<IsParseState StateType, typename T, typename ListType>
+	constexpr auto construct_list<StateType, T, ListType, true> = callback<T*>(
+		[](StateType& state, const char* begin, ListType&& arg, const char* end) {
+			return state.ast().template create<T>(NodeLocation::make_from(begin, end), DRYAD_FWD(arg));
+		},
+		[](StateType& state, const char* begin, lexy::nullopt, const char* end) {
+			return state.ast().template create<T>(NodeLocation::make_from(begin, end));
+		});
+
+	template<unsigned char LOW, unsigned char HIGH>
+	consteval auto make_range() {
+		if constexpr (LOW == HIGH) {
+			return ::lexy::dsl::lit_c<LOW>;
+		} else if constexpr (LOW == (HIGH - 1)) {
+			return ::lexy::dsl::lit_c<LOW> / ::lexy::dsl::lit_c<HIGH>;
+		} else {
+			return ::lexy::dsl::lit_c<LOW> / make_range<LOW + 1, HIGH>();
+		}
+	}
+
+	template<auto Open, auto Close>
+	constexpr auto position_brackets = lexy::dsl::brackets(lexy::dsl::position(lexy::dsl::lit_c<Open>), lexy::dsl::position(lexy::dsl::lit_c<Close>));
+
+	constexpr auto round_bracketed = position_brackets<'(', ')'>;
+	constexpr auto square_bracketed = position_brackets<'[', ']'>;
+	constexpr auto curly_bracketed = position_brackets<'{', '}'>;
+	constexpr auto angle_bracketed = position_brackets<'<', '>'>;
+
+	template<typename Production>
+	constexpr auto p = lexy::dsl::position(lexy::dsl::p<Production>);
+
+	template<IsParseState ParseType, typename ReturnType, ovdl::detail::string_literal Keyword>
+	static constexpr auto default_kw_value = dsl::callback<ReturnType*>(
+		[](ParseType& state, NodeLocation loc) {
+			return state.ast().template create<ReturnType>(loc, state.ast().intern(Keyword.data(), Keyword.size()));
+		});
+
+	template<
+		IsParseState ParseType,
+		typename Identifier,
+		typename RuleValue,
+		ovdl::detail::string_literal Keyword,
+		auto Production,
+		auto Value>
+	struct keyword_rule {
+		struct rule_t {
+			static constexpr auto keyword = ovdl::dsl::keyword<Keyword>(lexy::dsl::inline_<Identifier>);
+			static constexpr auto rule = lexy::dsl::position(keyword) >> lexy::dsl::equal_sign;
+			static constexpr auto value = Value;
+		};
+		static constexpr auto rule = dsl::p<rule_t> >> Production;
+		static constexpr auto value = construct<ParseType, RuleValue>;
+	};
+
+	template<
+		IsParseState ParseType,
+		typename Identifier,
+		typename RuleValue,
+		ovdl::detail::string_literal Keyword,
+		auto Production,
+		auto Value>
+	struct fkeyword_rule : keyword_rule<ParseType, Identifier, RuleValue, Keyword, Production, Value> {
+		using base_type = keyword_rule<ParseType, Identifier, RuleValue, Keyword, Production, Value>;
+		struct context_t;
+		struct rule_t : base_type::rule_t {
+			static constexpr auto flag = lexy::dsl::context_flag<context_t>;
+			struct too_many_error {
+				static constexpr auto name = "expected event " + Keyword + " to only be found once";
+			};
+			static constexpr auto must = lexy::dsl::must(rule_t::flag.is_reset())
+											 .
+// See https://stackoverflow.com/questions/77144003/use-of-template-keyword-before-dependent-template-name
+// THANKS FOR NOTHING MICROSOFT, CAN'T EVEN GET THE STANDARD RIGHT
+#if !defined(_MSC_VER) || defined(__clang__)
+										 template
+#endif
+										 error<too_many_error>;
+		};
+		static constexpr auto make_flag = rule_t::flag.create();
+
+		static constexpr auto rule = dsl::p<rule_t> >> (rule_t::must >> rule_t::flag.set()) >> Production;
+		static constexpr auto value = construct<ParseType, RuleValue>;
+	};
+
+	template<typename... Args>
+	struct rule_helper {
+		static constexpr auto flags = (Args::make_flag + ...);
+		static constexpr auto p = (lexy::dsl::p<Args> | ...);
+	};
+}
\ No newline at end of file