valeri/src/compiler.hpp

#pragma once

#include "common.hpp"

struct Context;

struct Expression {
  Expression() {}
  Expression(Array&& code) : reg(0), code(std::move(code)) {}

  static Result<Expression> create() {
    Array c = TRY(Array::create());

    return Expression(std::move(c));
  }
  Result<void> add_opcode(Oc opcode, OpArg arg1 = {0, 0}, OpArg arg2 = {0, 0},
                          OpArg arg3 = {0, 0}, OpArg arg4 = {0, 0});

  Result<void> add_code(Array& c) {
    code = TRY(code.concat(c));
    return Result<void>();
  }
  uint64_t reg;
  Array code;
};

class Compiler {
 public:
  Compiler() {}

  Result<Value> compile(Value& expr);
  Result<Expression> compile_expr(Context& context, Value& expr);
  Result<Expression> compile_list(Context& context, Pair& expr);
  Result<Expression> compile_primop(Context& context, Symbol& op, Pair& expr);
  Result<Expression> compile_comparison(Context& context, Symbol& op,
                                        Pair& expr);
  Result<Expression> compile_constant(Context& context, Value& value);
  Result<Expression> compile_symbol(Context& context, Symbol& value);
  Result<Expression> compile_bool(Context& context, Bool& value);
  Result<Expression> compile_if(Context& context, Symbol& op, Pair& expr);
  Result<Expression> compile_and(Context& context, Symbol& op, Pair& expr);
  Result<Expression> compile_or(Context& context, Symbol& op, Pair& expr);
  Result<Expression> compile_not(Context& context, Symbol& op, Pair& expr);
  Result<Expression> compile_fn(Context& context, Symbol& op, Pair& expr);
  Result<Expression> compile_body(Context& context, Pair& expr);
  Result<Expression> compile_function_call(Context& context, Pair& expr);
};

Result<Value> compile(Value& expr);