limn.h

Go to the documentation of this file.

#pragma once

#include <cctype>
#include <string_view>
#include <functional> // support match function call

#ifndef _MSC_VER
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wshadow"
#endif

namespace lm {

    class Skipper
    {
    public:
        virtual bool skip(std::string_view& sv) noexcept  = 0;
    };

    class SkipWhitespace : public Skipper
    {
    public:
        bool skip(std::string_view& sv) noexcept {
            // whitespace could be: [ \t\r\n]+, see below
            // https://en.cppreference.com/w/cpp/string/byte/isspace
            bool remove_char = false;
            while (!sv.empty() && 0 != std::isspace(sv.front())) { // skip the whitespace chars
                sv.remove_prefix(1);
                remove_char = true;
            }
            return remove_char;
        };
    };

    class NoSkip : public Skipper
    {
    public:

        bool skip(std::string_view& sv) noexcept {
            return true;
        };
    };

    static SkipWhitespace skws;
    static NoSkip nosk;


    namespace impl {

        template <typename Base>
        struct parser_base {
            constexpr auto operator*() const noexcept;
            constexpr auto operator+() const noexcept;
            constexpr auto operator[](std::string_view& output) const noexcept;
            constexpr auto operator[](std::function<void(const std::string_view&)> callback) const noexcept;
        };
    }

    struct char_ final : public impl::parser_base<char_> {
        constexpr explicit char_(const char ch) noexcept
            : ch(ch)
        {}

        constexpr inline auto operator!() const& noexcept {
            struct not_ final : impl::parser_base<not_> {
                constexpr explicit not_(const char ch) noexcept
                    : ch(ch)
                {}

                constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
                    if (!sv.empty() && sv.front() != ch) {
                        sv.remove_prefix(1);
                        return true;
                    }
                    return false;
                }

            private:
                char ch;
            };

            return not_(ch);
        }

        constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
            if (!sv.empty() && sv.front() == ch) {
                sv.remove_prefix(1);
                return true;
            }
            return false;
        }

    private:
        char ch;
    };

    struct charset_ final : public impl::parser_base<charset_> {
        constexpr explicit charset_(char const* set) noexcept
            : set(set)
        {}

        constexpr inline auto operator!() const& noexcept {
            struct not_ final : impl::parser_base<not_> {
                constexpr explicit not_(char const* set) noexcept
                    : set(set)
                {}

                constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
                    if (!sv.empty()) {
                        for (char const* s = set; *s; ++s) {
                            if (*s == sv.front()) {
                                return false;
                            }
                        }
                        sv.remove_prefix(1);
                        return true;
                    }
                    return false;
                }

            private:
                char const* set;
            };

            return not_(set);
        }

        constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
            if (!sv.empty()) {
                for (char const* s = set; *s; ++s) {
                    if (*s == sv.front()) {
                        sv.remove_prefix(1);
                        return true;
                    }
                }
            }
            return false;
        }

    private:
        char const* set;
    };

    struct char_if_ final : public impl::parser_base<char_if_> {
        constexpr explicit char_if_(bool(*pred)(char)) noexcept
            : pred(pred)
        {}

        constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
            if (!sv.empty() && pred(sv.front())) {
                sv.remove_prefix(1);
                return true;
            }
            return false;
        }

    private:
        bool(*pred)(char);
    };

    // These are not constexpr because the underlying functions in cctype aren't

    [[maybe_unused ]] static inline auto alnum_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::isalnum(ch); });

    [[maybe_unused ]] static inline auto alpha_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::isalpha(ch); });

    [[maybe_unused ]] static inline auto lower_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::islower(ch); });

    [[maybe_unused ]] static inline auto upper_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::isupper(ch); });

    [[maybe_unused ]] static inline auto digit_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::isdigit(ch); });

    [[maybe_unused ]] static inline auto xdigit_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::isxdigit(ch); });

    [[maybe_unused ]] static inline auto cntrl_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::iscntrl(ch); });

    [[maybe_unused ]] static inline auto graph_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::isgraph(ch); });

    [[maybe_unused ]] static inline auto space_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::isspace(ch); });

    [[maybe_unused ]] static inline auto blank_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::isblank(ch); });

    [[maybe_unused ]] static inline auto print_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::isprint(ch); });

    [[maybe_unused ]] static inline auto punct_ = char_if_([](char const ch) noexcept -> bool { return 0 != std::ispunct(ch); });

    struct lit_ final : public impl::parser_base<lit_> {
        constexpr lit_(std::string_view str) noexcept
            : str(str)
        {}

        constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
            if (sv.substr(0, str.size()) == str) {
                sv.remove_prefix(str.size());
                return true;
            }
            return false;
        }

    private:
        std::string_view str;
    };

    template <typename Func>
    struct action_ final : public impl::parser_base<action_<Func>> {
        constexpr explicit action_(Func&& func) noexcept
            : func(std::forward<Func>(func))
        {}

        constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
            return func(sv); // func returns false to fail the parse
        }

    private:
        Func func;
    };

    template <typename Base>
    struct opt_ final : public impl::parser_base<opt_<Base>> {
        constexpr explicit opt_(Base base) noexcept
            : base(std::forward<Base>(base))
        {}

        constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
            skipper.skip(sv);
            base.visit(sv, skipper);
            return true;
        }

    private:
        Base base;
    };

    template <typename Base>
    struct lexeme_ final : public impl::parser_base<lexeme_<Base>> {
        constexpr explicit lexeme_(Base base) noexcept
            : base(std::forward<Base>(base))
        {}

        constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
            // skipper.skip(sv);
            // nosk.skip(sv);
            return base.visit(sv, nosk); // lexeme is atomic, so don't use passed skipper, use nosk instead;
        }

    private:
        Base base;
    };

    namespace impl {
        template <typename Left, typename Right>
        struct seq_ final : public impl::parser_base<seq_<Left, Right>> {
            constexpr explicit seq_(Left&& left, Right&& right) noexcept
                : left(std::forward<Left>(left))
                , right(std::forward<Right>(right))
            {}

            constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
                skipper.skip(sv);
                bool left_result = left.visit(sv, skipper);
                if (left_result)
                {
                    skipper.skip(sv);
                    return right.visit(sv, skipper);
                }
                else
                    return false;
            }

        private:
            Left left;
            Right right;
        };

        template <typename Left, typename Right>
        struct alt_ final : public impl::parser_base<alt_<Left, Right>> {
            constexpr explicit alt_(Left&& left, Right&& right) noexcept
                : left(std::forward<Left>(left))
                , right(std::forward<Right>(right))
            {}

            constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
                skipper.skip(sv);
                const std::string_view save = sv; // rewind the string_view if left failed, save should not be reference
                return left.visit(sv, skipper) || right.visit(sv = save, skipper);  // reset the sv when calling the right parser
            }

        private:
            Left left;
            Right right;
        };

        template <typename Base>
        struct kleene_ final : public impl::parser_base<kleene_<Base>> {
            constexpr explicit kleene_(Base base) noexcept
                : base(std::move(base))
            {}

            constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
                skipper.skip(sv);
                std::string_view save = sv;
                // save != sv means we does step forward (base.visit(sv) consume some chars)
                // the assignment save = sv means the sv get updated, so try next loop
                // to see it goes forward again
                while (base.visit(sv, skipper) && !sv.empty() && save != sv)
                    save = sv;
                return true;
            }

        private:
            Base base;
        };

        template <typename Base>
        struct plus_ final : public impl::parser_base<plus_<Base>> {
            constexpr explicit plus_(Base base) noexcept
                : base(std::move(base))
            {}

            constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
                skipper.skip(sv);
                if (!base.visit(sv, skipper)) {
                    return false;
                }
                std::string_view save = sv;
                // save != sv means we does step forward (base.visit(sv) consume some chars)
                // the assignment save = sv means the sv get updated, so try next loop
                // to see it goes forward again
                while (base.visit(sv, skipper) && !sv.empty() && save != sv)
                    save = sv;
                return true;
            }

        private:
            Base base;
        };

        template <typename Base>
        struct match_ final : public impl::parser_base<match_<Base>> {
            constexpr explicit match_(Base base, std::string_view& sv) noexcept
                : base(std::move(base))
                , out(sv)
            {}

            constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
                skipper.skip(sv);
                std::string_view save = sv;
                if (base.visit(sv, skipper)) {
                    out = save.substr(0, save.size() - sv.size());
                    return true;
                }
                return false;
            }

        private:
            Base base;
            std::string_view& out;
        };

        template <typename Base>
        struct match_call_ final : public impl::parser_base<match_call_<Base>> {
            constexpr explicit match_call_(Base base, std::function<void(const std::string_view&)> callback) noexcept
                : base(std::move(base))
                , callback(std::move(callback))
            {}

            constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
                skipper.skip(sv);
                std::string_view save = sv;
                if (base.visit(sv, skipper)) {
                    callback(save.substr(0, save.size() - sv.size()));
                    return true;
                }
                return false;
            }

        private:
            Base base;
            std::function<void(const std::string_view&)> callback;
        };

        struct endtype_ final : public impl::parser_base<endtype_> {
            constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
                return sv.empty();
            }
        };

        struct emptytype_ final : public impl::parser_base<emptytype_> {
            constexpr inline bool visit(std::string_view& sv, Skipper& skipper) const& noexcept {
                return true;
            }
        };
    }

    [[maybe_unused]] constexpr static inline auto end_ = impl::endtype_();

    [[maybe_unused]] constexpr static inline auto empty_ = impl::emptytype_();

    template <typename Left, typename Right>
    constexpr inline auto operator>>(Left&& left, Right&& right) noexcept {
        return impl::seq_<Left, Right>(
            std::forward<Left>(left),
            std::forward<Right>(right)
        );
    }

    template <typename Left, typename Right>
    constexpr inline auto operator|(Left&& left, Right&& right) noexcept {
        return impl::alt_<Left, Right>(
            std::forward<Left>(left),
            std::forward<Right>(right)
        );
    }

    template <typename Base>
    constexpr inline auto impl::parser_base<Base>::operator*() const noexcept {
        return impl::kleene_<Base>(*static_cast<Base const*>(this));
    }

    template <typename Base>
    constexpr inline auto impl::parser_base<Base>::operator+() const noexcept {
        return impl::plus_<Base>(*static_cast<Base const*>(this));
    }

    template <typename Base>
    constexpr inline auto impl::parser_base<Base>::operator[](std::string_view& ouput) const noexcept {
        return impl::match_<Base>(*static_cast<Base const*>(this), ouput);
    }

    template <typename Base>
    constexpr inline auto impl::parser_base<Base>::operator[](std::function<void(const std::string_view&)> callback) const noexcept {
        return impl:: match_call_<Base>(*static_cast<Base const*>(this), std::move(callback));
    }

    template <typename Parser>
    constexpr bool parse(std::string_view input, Parser const& parser, Skipper& skipper = skws) noexcept {
        return parser.visit(input, skipper);
    }

    template <typename Parser>
    constexpr bool parse_ref(std::string_view& input, Parser const& parser, Skipper& skipper = skws) noexcept {
        return parser.visit(input, skipper);
    }
}

#ifndef _MSC_VER
#pragma GCC diagnostic pop
#endif