interpreter.h

#ifndef SPUDPLATE_INTERPRETER_H
#define SPUDPLATE_INTERPRETER_H
 
#include <cstdint>
#include <iosfwd>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>
 
#include "spudplate/ast.h"
#include "spudplate/spudpack.h"
 
namespace spudplate {
 
class RuntimeError : public std::runtime_error {
  public:
    RuntimeError(const std::string& message, int line, int column)
        : std::runtime_error(message), line_(line), column_(column) {}
 
    [[nodiscard]] int line() const { return line_; }
    [[nodiscard]] int column() const { return column_; }
 
  private:
    int line_;
    int column_;
};
 
using Value = std::variant<std::string, std::int64_t, bool>;
 
class Environment {
  public:
    Environment() { push(); }
 
    void push() { frames_.emplace_back(); }
    void pop() { frames_.pop_back(); }
 
    void declare(const std::string& name, Value value);
 
    void assign(const std::string& name, Value value);
 
    [[nodiscard]] std::optional<Value> lookup(const std::string& name) const;
 
  private:
    std::vector<std::unordered_map<std::string, Value>> frames_;
};
 
struct PromptRequest {
    std::string text;                         
    VarType type;                             
    std::vector<std::string> options;         
    std::optional<std::string> default_value; 
    std::optional<std::string> previous_error;
    int question_index{0};                    
    int question_total{0};                    
    int indent_level{0};                      
    std::vector<std::pair<std::int64_t, std::int64_t>> iterations; 
};
 
class Prompter {
  public:
    virtual ~Prompter() = default;
 
    virtual std::string prompt(const PromptRequest& req) = 0;
 
    virtual bool authorize(const std::string& summary) = 0;
};
 
class StdinPrompter : public Prompter {
  public:
    StdinPrompter();
    StdinPrompter(std::istream& in, std::ostream& out, bool use_colour);
 
    std::string prompt(const PromptRequest& req) override;
    bool authorize(const std::string& summary) override;
 
  private:
    std::istream& in_;
    std::ostream& out_;
    bool use_colour_;
};
 
class ScriptedPrompter : public Prompter {
  public:
    explicit ScriptedPrompter(std::vector<std::string> answers)
        : answers_(std::move(answers)) {}
 
    std::string prompt(const PromptRequest& req) override;
    bool authorize(const std::string& summary) override;
 
    [[nodiscard]] const std::optional<PromptRequest>& last_request() const {
        return last_;
    }
 
    [[nodiscard]] const std::vector<PromptRequest>& requests() const {
        return requests_;
    }
 
    void set_authorize_response(bool value) { authorize_response_ = value; }
 
    [[nodiscard]] const std::optional<std::string>& last_authorize_summary() const {
        return last_authorize_summary_;
    }
 
  private:
    std::vector<std::string> answers_;
    std::size_t index_{0};
    std::optional<PromptRequest> last_;
    std::vector<PromptRequest> requests_;
    bool authorize_response_{true};
    std::optional<std::string> last_authorize_summary_;
};
 
class SourceProvider {
  public:
    virtual ~SourceProvider() = default;
 
    struct Entry {
        std::string path;       
        bool is_directory;      
        std::uint16_t mode;     
    };
 
    virtual std::pair<std::vector<std::uint8_t>, std::uint16_t> read(
        std::string_view path) const = 0;
 
    virtual std::vector<Entry> list_under(std::string_view prefix) const = 0;
};
 
class AssetMapSourceProvider final : public SourceProvider {
  public:
    explicit AssetMapSourceProvider(const std::vector<SpudpackAsset>& assets);
 
    std::pair<std::vector<std::uint8_t>, std::uint16_t> read(
        std::string_view path) const override;
    std::vector<Entry> list_under(std::string_view prefix) const override;
 
  private:
    const std::vector<SpudpackAsset>& assets_;
    std::unordered_map<std::string, std::size_t> index_;
};
 
void run(const Program& program, Prompter& prompter,
         bool skip_authorization = false,
         const SourceProvider* source = nullptr,
         bool timeouts_disabled = false,
         const std::vector<SpudpackDep>* deps = nullptr);
 
Environment run_for_tests(const Program& program, Prompter& prompter,
                          const SourceProvider* source = nullptr,
                          const std::vector<SpudpackDep>* deps = nullptr);
 
void dry_run(const Program& program, Prompter& prompter, std::ostream& out,
             bool ascii_only = false,
             const SourceProvider* source = nullptr,
             const std::vector<SpudpackDep>* deps = nullptr);
 
bool locale_is_utf8();
 
Value evaluate_expr(const Expr& expr, const Environment& env);
 
std::string value_to_string(const Value& value);
 
using AliasMap = std::unordered_map<std::string, std::string>;
 
std::string evaluate_path(const PathExpr& path, const Environment& env,
                          const AliasMap& aliases);
 
}  // namespace spudplate
 
#endif  // SPUDPLATE_INTERPRETER_H