parser.h

//#include "interpolate.h"

#include "srell/srell.hpp"

#include <filesystem>
#include <kblib/poly_obj.h>
#include <map>

namespace fs = std::filesystem;

namespace parser {

class TokenStream;

namespace AST {

    struct ASTNode {
        // virtual void parse(TokenStream& input) = 0;

        virtual ~ASTNode() = default;

        static constexpr std::size_t max_derived_size = 64;
    };

    template <typename T, typename B = ASTNode>
    struct List : B {
        std::vector<T> vals;
        static_assert(std::is_base_of_v<ASTNode, B>);
    };
    template <typename K, typename V, typename B = ASTNode>
    struct Map : B {
        std::map<K, V> vals;
        static_assert(std::is_base_of_v<ASTNode, B>);
    };
    template <typename B, typename... Ts>
    struct BTuple : B {
        std::tuple<Ts...> vals;
        static_assert(std::is_base_of_v<ASTNode, B>);
    };
    template <typename... Ts>
    using Tuple = BTuple<ASTNode, Ts...>;

    struct TExpr : ASTNode {
        static constexpr std::size_t max_derived_size =
            sizeof(ASTNode) + sizeof(std::string) + sizeof(std::vector<int>);
    };
    struct TLiteral : TExpr {
        std::string val;
    };
    struct TFCall : TExpr {
        std::string fname;
        std::vector<kblib::poly_obj<TExpr>> args;
    };
    struct TArgRef : TExpr {
        std::string name;
    };
    struct TDots : TArgRef {};

    struct String : ASTNode {
        template <typename... Ts>
        std::tuple<std::optional<Ts>...> refine() const;
        static constexpr std::size_t max_derived_size =
            sizeof(ASTNode) + sizeof(std::vector<int>);
    };
    struct tname : String {
        std::string name;
        int argc;
        bool variadic;
    };
    struct LString final : String {
        std::string val;
    };
    struct IString : String {};
    struct TString : String {
        std::vector<std::variant<std::string, TExpr>> contents;
    };

    struct replace_stage : ASTNode {};
    struct regex_action final : ASTNode {
        srell::regex r;
        std::string m;
    };
    struct regex_stage final : List<regex_action, replace_stage> {};
    struct state_machine final : replace_stage {};

    struct Replacement_group final : ASTNode {
        std::map<std::string, List<kblib::poly_obj<replace_stage>>> actions;
    };
    struct Control final : ASTNode {
        std::map<std::string, std::string> channel_names;
        std::map<tname, TString> functions;
        std::vector<Replacement_group> replacements;
        IString entry_point;

        // void parse(TokenStream& input) override;
    };

    struct Alternative : ASTNode {
        auto val() const -> String&;
        std::variant<double, TString> freq;
        Map<std::string, kblib::poly_obj<String>> channels;
    };

    struct Node {};
    struct NormalNode final : List<Alternative> {};
    struct LiteralNode final : Alternative {};

    struct Datafile final : ASTNode {
        Control control;
        Map<tname, kblib::poly_obj<Node>> nodes;
    };
} // namespace AST

} // namespace parser