You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
121 lines
3.6 KiB
121 lines
3.6 KiB
|
|
#include <cstring>
|
|
|
|
#include <input.h>
|
|
|
|
namespace {
|
|
template<typename T>
|
|
[[gnu::pure]]
|
|
inline T* gmemchr(T* ptr, char ch, size_t sz) noexcept {
|
|
return (T*)memchr((void*)ptr, ch, sz * sizeof(T));
|
|
}
|
|
|
|
template<typename T>
|
|
inline size_t gmemchr_s(T* ptr, char ch, size_t sz) noexcept {
|
|
if(T* p = gmemchr(ptr, ch, sz)) return (size_t)(p - ptr);
|
|
else return 0;
|
|
}
|
|
|
|
template<typename F> requires(std::is_invocable_v<F>)
|
|
struct Defer {
|
|
constexpr explicit Defer(std::nullptr_t) noexcept
|
|
: f(nullptr) {}
|
|
constexpr Defer(F&& func) noexcept(std::is_nothrow_move_constructible_v<F>)
|
|
: f(std::make_unique<F>(std::move(func))) {}
|
|
constexpr virtual ~Defer() noexcept(std::is_nothrow_invocable_v<F>) { if(f) (*f)(); }
|
|
|
|
constexpr Defer(Defer&& m) noexcept
|
|
: f(std::move(m.f)) {}
|
|
constexpr Defer(const Defer& p) noexcept requires(std::is_copy_constructible_v<F>)
|
|
: f(p.f ? *p.f : nullptr) {}
|
|
constexpr Defer& operator=(Defer&& m) noexcept(std::is_nothrow_move_constructible_v<F>)
|
|
{
|
|
if(this != std::addressof(m)) {
|
|
f = std::move(m.f);
|
|
} return *this;
|
|
}
|
|
constexpr Defer& operator=(const Defer& c) noexcept(std::is_nothrow_copy_constructible_v<F>) requires(std::is_copy_constructible_v<F>)
|
|
{
|
|
if(this != std::addressof(m)) {
|
|
if(c.f) f = std::make_unique<F>(*c.f);
|
|
else f = nullptr;
|
|
} return *this;
|
|
}
|
|
|
|
template<typename... Args>
|
|
constexpr decltype(auto) operator()(Args&&... args) noexcept(std::is_nothrow_invocable_v<F, Args...>) requires(std::is_invocable_v<F, Args...>)
|
|
{ return std::forward<std::invoke_result_t<F, Args...>>( (*f)() ); }
|
|
private:
|
|
std::unique_ptr<F> f;
|
|
};
|
|
template<typename F> requires(std::is_invocable_v<F>)
|
|
constexpr auto defer_call(F&& func) noexcept(std::is_nothrow_move_constructible_v<F>) { return Defer<F>{std::move(func)}; }
|
|
#define $CAT_(a, b) a ## b
|
|
#define $CAT(a, b) $CAT_(a, b)
|
|
#define $DEFER(...) const auto $CAT(_$__defer_, __LINE__) = ::defer_call( __VA_ARGS__ )
|
|
}
|
|
|
|
namespace Input {
|
|
struct Parser::_impl {
|
|
struct {
|
|
const char* data;
|
|
size_t len;
|
|
} src;
|
|
|
|
const char* cur_line;
|
|
size_t cur_len;
|
|
};
|
|
Parser::Parser(const char* string, size_t len) noexcept
|
|
: state_(std::make_unique<_impl>())
|
|
{
|
|
state_->cur_line = state_->src.data = string;
|
|
state_->cur_len = state_->src.len = len;
|
|
}
|
|
|
|
Parser::~Parser() {}
|
|
|
|
Parser::Parser(Parser&& p) noexcept
|
|
: state_(std::move(p.state_)) {}
|
|
|
|
Parser& Parser::operator=(Parser&& p) noexcept
|
|
{
|
|
if(this != std::addressof(p)) {
|
|
state_ = std::move(p.state_);
|
|
} return *this;
|
|
}
|
|
|
|
bool Parser::try_read_next(Output<Line> output)
|
|
{
|
|
const char* start = state_->cur_line;
|
|
const char* end = gmemchr(start, '\n', state_->cur_len);
|
|
if(!end) return false;
|
|
|
|
size_t diff = (size_t)(end - state_->cur_line);
|
|
|
|
if(diff > 1) {
|
|
auto string = std::string_view{ start, gmemchr_s(start, ' ', diff - 1) };
|
|
|
|
for(size_t i=0;
|
|
string.size() && string.data() < end;
|
|
i++,
|
|
string = std::string_view{ start += string.size(), // start = start + last size
|
|
gmemchr_s(start, ' ', diff - 1) // XXX: <-- this should be `start + string.size()`
|
|
})
|
|
{
|
|
switch(i) {
|
|
case 0: output->start = parse_point(string); break; // First point
|
|
case 1: continue; // Arrow
|
|
case 2: output->end = parse_point(string); break; // Second point
|
|
case 3: continue; // Arrow
|
|
default: goto le; // Next point, quit
|
|
}
|
|
}
|
|
le:
|
|
end = ((const char*)string.data()) + string.size();
|
|
state_->cur_len = (size_t)(end - state_->cur_line); // TODO: Is this the correct length calculation? I don't think it is....
|
|
state_->cur_line = end;
|
|
return true;
|
|
} else return false;
|
|
}
|
|
}
|