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;
};

bool is_primitive_op(Symbol& sym) {
  // return (sym.cmp("+") == 0);
  return false;
}

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

  TRY(compile_expr(context, expr));
  return ErrorCode::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 ErrorCode::TypeMismatch;
  }
  return ErrorCode::TypeMismatch;
}

Result<Expression> Compiler::compile_list(Context& context, Pair& expr) {
  auto first = TRY(expr.first());

  if (first.is<Symbol>()) {
    Symbol& sym = *first.to<Symbol>();
  }
  return ErrorCode::TypeMismatch;
}