valeri/src/compiler.cpp

#include "compiler.hpp"

struct Context {
  Context() {}
  Context(Value&& env, Array&& constants)
      : env(std::move(env)),
        constants(std::move(constants)),
        maxreg(0),
        maxconst(0) {}

  static Result<Context> create() {
    auto env = TRY(Nil::create());
    auto constants = TRY(Array::create());

    return Context(std::move(env), std::move(constants));
  }

  Value env;
  Array constants;
  uint64_t maxreg;
  uint64_t maxconst;
};

Result<bool> is_primitive_op(Symbol& sym) {
  return TRY(sym.cmp("+")) == 0 || TRY(sym.cmp("-")) == 0 ||
         TRY(sym.cmp("*")) == 0 || TRY(sym.cmp("/")) == 0;
  return false;
}

Result<Value> Compiler::compile(Value& expr) {
  auto context = TRY(Context::create());

  TRY(compile_expr(context, expr));
  return ERROR(NotImplemented);
}
Result<Expression> Compiler::compile_expr(Context& context, Value& expr) {
  switch (expr.tag()) {
    case Tag::Pair:
      return compile_list(context, *expr.to<Pair>());
    case Tag::Nil:
    case Tag::Bool:
    case Tag::Int64:
    case Tag::Float:
    case Tag::String:
    case Tag::Symbol:
    case Tag::Syntax:
    case Tag::Array:
    case Tag::ByteArray:
    case Tag::Dict:
      return ERROR(TypeMismatch);
  }
  return ERROR(TypeMismatch);
}

Result<Expression> Compiler::compile_primop(Context& context, Symbol& op,
                                            Pair& expr) {
  std::cout << "primop\n";

  Value cur = TRY(expr.rest());
  Array code = TRY(Array::create());

  while (!cur.is<Nil>()) {
    Pair& pair = *cur.to<Pair>();
    auto subexpr = TRY(pair.first());

    auto comp = TRY(compile_expr(context, subexpr));

    cur = TRY(pair.rest());
  }
  return ERROR(TypeMismatch);
}
Result<Expression> Compiler::compile_list(Context& context, Pair& expr) {
  auto first = TRY(expr.first());

  if (first.is<Symbol>()) {
    Symbol& sym = *first.to<Symbol>();
    if (TRY(is_primitive_op(sym))) {
      return compile_primop(context, sym, expr);
    }
  }
  return ERROR(TypeMismatch);
}