tstrings.h

#ifndef TSTRINGS_H_INCLUDED_
#define TSTRINGS_H_INCLUDED_

#define KBLIB_DEF_MACROS 1
#include "kblib/kblib.h"

#include "cppcoro/generator.hpp"
#include <map>
#include <memory>
#include <numeric>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <variant>
#include <vector>

#include "containers.h"
#include "error.h"
#include "floating_array.h"
#include "random.h"

// TODO(killerbee): Switch to lazy evaluation

// move to grammar file header
// translate old-style doubled-character escapes into backslash escapes
inline std::string compat_filter(std::string_view in) {
    std::string ret;
    bool esc = false;
    for (auto [c, i] : kblib::enumerate(in)) {
        if (esc) {
            if (c == in[i - 1]) {
                ret.push_back('\\');
                ret.push_back(c);
            } else {
                ret.push_back(in[i - 1]);
                ret.push_back(c);
            }
        }
        if (kblib::contains("<>{}", c)) {
            esc = true;
        } else {
            ret.push_back(c);
        }
    }
    return ret;
}
// remove backslash-escape sequences
[[nodiscard]] inline std::string unescape(std::string_view in) {
    bool b_esc = false;
    bool d_esc = false;
    std::string ret;
    char prev{};
    for (auto& c : in) {
        if (d_esc) {
            if (c == prev) {
                ret.push_back(c);
            } else {
                ret.push_back(prev);
                ret.push_back(c);
            }
            d_esc = false;
        } else if (b_esc) {
            ret.push_back(c);
            b_esc = false;
        } else {
            if (c == '\\') {
                b_esc = true;
            } else if (c == '<' or c == '>') {
                d_esc = true;
            } else {
                ret.push_back(c);
            }
        }
        prev = c;
    }
    return ret;
}

std::pair<int, bool> argsDeclared(std::string_view in);

struct node;

using arg_t = std::variant<std::string, std::vector<std::string>, const node*,
                           wordgen_error /*, std::unique_ptr<node>*/>;
using argslist = std::vector<arg_t>;

[[nodiscard]] std::string stringize(const arg_t& arg);
[[nodiscard]] std::string stringize(arg_t&& arg);

class transformer {
 public:
    [[nodiscard]] virtual arg_t operator()(argslist) const = 0;
    virtual ~transformer() noexcept = default;
};

class Echo final : public transformer {
 public:
    [[nodiscard]] arg_t operator()(argslist v) const override;
};

class bytecode_machine;

class Evaluator final : public transformer {
 public:
    Evaluator(bytecode_machine* owner) : owner(owner) {}
    [[nodiscard]] arg_t operator()(argslist v) const override;

 private:
    bytecode_machine* owner;
};

namespace helpers {
template <typename T>
using _t_h =
    std::is_convertible<decltype(std::declval<T>()(std::declval<argslist>())),
                        arg_t>;

template <typename T, typename = std::void_t<>>
struct is_transformer :
    // can't find is_invocable
    // std::is_invocable<arg_t, T, argslist>
    public std::false_type {};

template <typename T>
struct is_transformer<T, std::void_t<_t_h<T>>> : public _t_h<T> {};

template <typename T>
constexpr bool is_transformer_v = is_transformer<T>::value;
}; // namespace helpers

template <typename Callable,
          typename std::enable_if_t<helpers::is_transformer_v<Callable>, int> =
              0>
class dynamic_transformer final : public transformer {
 public:
    dynamic_transformer(Callable _c) : c(std::move(_c)) {}
    [[nodiscard]] arg_t operator()(argslist v) const override {
        return c(std::move(v));
    }

 private:
    Callable c;
};

template <typename Callable>
[[nodiscard]] std::unique_ptr<dynamic_transformer<std::decay_t<Callable>>>
make_transformer(Callable&& c) {
    return std::make_unique<dynamic_transformer<std::decay_t<Callable>>>(
        std::forward<Callable>(c));
}

enum class op : unsigned char {
    null = 0,         // monostate
    text,             // string
    push_func,        // transformer*
    call_func,        // monostate
    argument,         // int
    special_argument, // string
    ellipsis,         // string
};

using op_data =
    std::variant<std::monostate, int, std::string, const transformer*>;

struct bytecode_op {
    op type;
    op_data data;
};
using bytecodes = boost::container::small_vector<bytecode_op, 16>;

struct token;
class datafile;

struct counters {
    int depthLimit{};
    int expansionsLimit{};
    int* expansions{nullptr};
    int depth{0};
};
inline counters incr(counters& c) {
    ++(*c.expansions);
    return {c.depthLimit, c.expansionsLimit, c.expansions, c.depth + 1};
}

using ArgsType =
    floating_array<std::variant<std::string, std::vector<std::string>>>;

ArgsType copy(const ArgsType& special, const std::vector<std::string>& vals);

[[nodiscard]] tmap<std::string, std::unique_ptr<transformer>>
default_transformers(bytecode_machine*, datafile*, RandomGenerator&);
[[nodiscard]] std::vector<std::pair<std::string, int>> default_names();

// One per data file
class bytecode_machine {
 private:
    tmap<std::string, std::unique_ptr<transformer>> transformers;
    std::vector<std::pair<std::string, int>> arg_names;

 public:
    bytecode_machine(datafile* owner, RandomGenerator& rng)
        : transformers(default_transformers(this, owner, rng)),
          arg_names(default_names()) {
        transformers["."] = std::make_unique<Echo>();
    }
    // t must map to a contiguous sequence of negative numbers ending at -1
    bytecode_machine(decltype(transformers) t, decltype(arg_names) a)
        : transformers(std::move(t)), arg_names(std::move(a)) {
        transformers["."] = std::make_unique<Echo>();
    }

    [[nodiscard]] bytecodes compile(const std::string&) const;
    [[nodiscard]] cppcoro::generator<std::string>
        to_bytes_test(std::string_view) const;
    [[nodiscard]] std::string eval(const bytecodes&,
                                   const std::vector<std::string>&,
                                   const counters&, int argc) const;

    std::map<std::string, arg_t> variables;

    // Given the name of a special argument, return its index in an ArgsType

    /* Special argument documentation:
     *
     * #p: escaped | (pipe) character
     * #lt: escaped < (less than) character
     * #gt: escaped > (greater than) character
     * #b: escaped \ (backslash) character
     *
     * #d: current expansion depth
     * #D: maximum expansion depth
     *
     * #e: current expansion count
     * #E: maximum expansion count
     *
     * #c: number of normal arguments passed to this node
     * #C: number of positional arguments declared by this node
     *
     * #a: a list containing the full series of declared arguments
     * ...: a list containing all extra (variadic) arguments
     * #A: the concatenation of #a and ...
     *
     */
    [[nodiscard]] int special_argument(std::string_view) const;
    [[nodiscard]] int min_argument() const;

    // Returns the transformer with the given name
    [[nodiscard]] const transformer& lookup(const std::string& name) const
        noexcept(false) {
        return *transformers.at(name);
    }

    // Returns a string which is a valid name for t
    // O(transformers.size()), so call it sparingly

    // Note that the reverse mapping is not unique, and the returned string is
    // unspecified in the ambiguous case. That is: given: std::string fun;
    // reverse_lookup(lookup(fun)) == fun
    // is unspecified
    // While:
    // given: const transformer *t;
    // &lookup(reverse_lookup(*t)) == t
    // is guaranteed
    [[nodiscard]] const std::string& reverse_lookup(const transformer& t) const
        noexcept(false);

    // register a new transformer by name
    // returns false if a transformer with that name already exists
    bool set(std::string key, std::unique_ptr<transformer> val) {
        return transformers.emplace(std::move(key), std::move(val)).second;
    }
    // re-assign a name to a new transformer (key must already be associated with
    // a transformer)
    void reset(const std::string& key, std::unique_ptr<transformer> val) {
        using namespace std::literals;
        // . is an invariant function
        assert(key != "."sv);
        auto it = transformers.find(key);
        assert(it !=
               transformers.end()); // reset does not register new transformers
        it->second = std::move(val);
    }
    // clears a key
    void unset(const std::string& key) {
        using namespace std::literals;
        assert(key != "."sv);
        auto it = transformers.find(key);
        assert(it != transformers.end()); // key must be registered already
        transformers.erase(it);
    }

 private:
    friend bytecode_op token_to_bytecode(token in, const bytecode_machine& b);
};

[[nodiscard]] std::string to_string(const bytecode_op& op,
                                    const bytecode_machine& b);
[[nodiscard]] std::string to_string(const op_data& op,
                                    const bytecode_machine& b);
[[nodiscard]] std::string serialize(const bytecode_op& op,
                                    const bytecode_machine& b);

#endif // TSTRINGS_H_INCLUDED_