valeri/src/writer.cpp

#include "writer.hpp"

#include "common.hpp"
#include "error.hpp"
#include "opcode.hpp"
#include "sourcerange.hpp"

Result<String> Writer::write_one(const Value& obj) {
  switch (obj.tag()) {
    case Tag::Nil:
      return write_nil(*obj.to<Nil>());
    case Tag::Int64:
      return write_int64(*obj.to<Int64>());
    case Tag::Float:
      return write_float(*obj.to<Float>());
    case Tag::Bool:
      return write_bool(*obj.to<Bool>());
    case Tag::Array:
      return write_array(*obj.to<Array>());
    case Tag::ByteArray:
      return write_bytearray(*obj.to<ByteArray>());
    case Tag::Dict:
      return write_dict(*obj.to<Dict>());
    case Tag::String:
      return write_string(*obj.to<String>());
    case Tag::Symbol:
      return write_symbol(*obj.to<Symbol>());
    case Tag::SrcLoc:
      return write_srcloc(*obj.to<SrcLoc>());
    case Tag::Syntax:
      return write_syntax(*obj.to<Syntax>());
    case Tag::Pair:
      return write_pair(*obj.to<Pair>());
    case Tag::Opcode:
      return write_opcode(*obj.to<Opcode>());
    case Tag::Function:
      return write_function(*obj.to<Function>());
    case Tag::StdlibFunction:
      return write_stdlib_function(*obj.to<StdlibFunction>());
    case Tag::Module:
      return write_module(*obj.to<Module>());
    case Tag::StackFrame:
      return write_stack(*obj.to<StackFrame>());
    case Tag::Error:
      return write_error(*obj.to<Error>());
    case Tag::Continuation:
      return write_continuation(*obj.to<Continuation>());
    case Tag::Task:
      return write_task(*obj.to<Task>());
    case Tag::TaskResult:
      return write_task_result(*obj.to<TaskResult>());
  };
  return String();
}

Result<String> Writer::write_multiple(const Value& val) {
  String res = TRY(String::create(""));

  Value cur = TRY(val.copy());

  bool is_first = true;
  while (!cur.is<Nil>()) {
    if (!cur.is<Pair>()) return ERROR(MalformedList);

    Pair& pair = *cur.to<Pair>();

    Value first = TRY(pair.first());
    if (!is_first) res = TRY(res.concat("\n"));

    String first_str = TRY(write_one(first));
    res = TRY(res.concat(first_str));

    cur = TRY(pair.rest());
    is_first = false;
  }

  res = TRY(res.concat(""));
  return res;
}

Result<String> Writer::write_int64(const Int64& val) {
  char tmp[32];
  sprintf(tmp, "%ld", val.value());
  size_t len = strlen(tmp);

  return String::create(tmp);
}

bool needs_dot(char* str) {
  bool has_e = 0;
  bool has_dot = 0;
  for (char* c = str; *c != 0; c++) {
    if (*c == 'e' || *c == 'E') has_e = true;
    if (*c == '.') has_dot = true;
  }
  return !has_e && !has_dot;
}

Result<String> Writer::write_float(const Float& val) {
  char tmp[32];
  sprintf(tmp, "%g", val.value());
  size_t len = strlen(tmp);

  if (needs_dot(tmp)) {
    tmp[len] = '.';
    tmp[len + 1] = '0';
    tmp[len + 2] = 0;
    len += 2;
  }

  return String::create(tmp);
}

Result<String> Writer::write_nil(const Nil& val) {
  return String::create("nil");
}

Result<String> Writer::write_bool(const Bool& val) {
  if (val.value()) return String::create("true");

  return String::create("false");
}

Result<String> Writer::write_bytearray(const ByteArray& val) {
  return ERROR(NotImplemented);
}

Result<String> Writer::write_string(const String& val) {
  String res = TRY(String::create("\""));
  auto size = TRY(val.size());
  // TODO: optimize this
  for (uint64_t i = 0; i < size; i++) {
    char32_t c = TRY(val[i]);
    const char* replace = 0;
    switch (c) {
      case '\r':
        replace = "\\r";
        break;
      case '\n':
        replace = "\\n";
        break;
      case '\t':
        replace = "\\t";
        break;
      case '\\':
        replace = "\\\\";
        break;
      case '"':
        replace = "\\\"";
        break;
      default:
        break;
    };

    if (replace != 0) {
      res = TRY(res.concat(replace));
    } else {
      res = TRY(res.concat(&c, 1));
    }
  }

  res = TRY(res.concat("\""));

  return res;
}

int is_valid_symbol_char(char32_t codepoint) {
  return ('a' <= codepoint && codepoint <= 'z') ||
         ('A' <= codepoint && codepoint <= 'Z') ||
         ('0' <= codepoint && codepoint <= '9') || codepoint == '!' ||
         codepoint == '$' || codepoint == '%' || codepoint == '&' ||
         codepoint == '*' || codepoint == '+' || codepoint == '-' ||
         codepoint == '.' || codepoint == '/' || codepoint == ':' ||
         codepoint == '<' || codepoint == '=' || codepoint == '>' ||
         codepoint == '?' || codepoint == '@' || codepoint == '^' ||
         codepoint == '_' || codepoint == '~';
}

Result<String> Writer::write_symbol(const Symbol& val) {
  String res = TRY(String::create(""));
  auto size = TRY(val.size());
  // TODO: optimize this
  for (uint64_t i = 0; i < size; i++) {
    char32_t c = TRY(val[i]);

    if (!is_valid_symbol_char(c)) return ERROR(InvalidSymbol);

    res = TRY(res.concat(&c, 1));
  }

  return res;
}

Result<String> Writer::write_srcloc(const SrcLoc& val) {
  char buf[1024];
  String res = TRY(String::create("#<srcloc "));

  SourceRange sr = val.sourcerange();
  snprintf(buf, 1024, "%lu:%lu %lu:%lu", sr.start.line, sr.start.column,
           sr.end.line, sr.end.column);

  res = TRY(res.concat(buf));
  res = TRY(res.concat(">"));
  return res;
}

Result<String> Writer::write_syntax(const Syntax& val) {
  auto res = TRY(String::create("#<syntax "));

  auto unwrapped = TRY(syntax_unwrap(TRY(val.copy_value())));
  auto str = TRY(write_one(unwrapped));

  res = TRY(res.concat(str));

  res = TRY(res.concat(">"));
  return res;
}

Result<String> Writer::write_pair(const Pair& val) {
  String res = TRY(String::create("("));

  Value cur = TRY(val.copy_value());

  bool is_first = true;
  while (!cur.is<Nil>()) {
    if (!cur.is<Pair>()) return ERROR(MalformedList);

    Pair& pair = *cur.to<Pair>();

    Value first = TRY(pair.first());
    if (!is_first) res = TRY(res.concat(" "));

    String first_str = TRY(write_one(first));
    res = TRY(res.concat(first_str));

    cur = TRY(pair.rest());
    is_first = false;
  }

  res = TRY(res.concat(")"));
  return res;
}

Result<String> Writer::write_array(const Array& val) {
  String res = TRY(String::create("["));

  bool is_first = true;
  auto size = TRY(val.size());
  for (uint64_t i = 0; i < size; i++) {
    Value cur = TRY(val.get(i));

    if (!is_first) res = TRY(res.concat(" "));

    String first_str = TRY(write_one(cur));
    res = TRY(res.concat(first_str));

    is_first = false;
  }

  res = TRY(res.concat("]"));
  return res;
}

Result<String> Writer::write_dict(const Dict& val) {
  String res = TRY(String::create("{"));

  bool is_first = true;
  auto size = TRY(val.size());
  for (uint64_t i = 0; i < size; i++) {
    Value k = TRY(Value::create(val._value->data[i * 2].get()));
    Value v = TRY(Value::create(val._value->data[i * 2 + 1].get()));

    if (!is_first) res = TRY(res.concat(" "));

    String first_str = TRY(write_one(k));
    res = TRY(res.concat(first_str));

    res = TRY(res.concat(" "));

    String second_str = TRY(write_one(v));
    res = TRY(res.concat(second_str));

    is_first = false;
  }

  res = TRY(res.concat("}"));
  return res;
}

Result<String> Writer::write_opcode(const Opcode& val) {
  String res = TRY(String::create("#<opcode "));

  const char* name = opcode_name(val.opcode());
  OpcodeType ot = opcode_type(val.opcode());

  char buf[256];
  switch (ot) {
    case OpcodeType::Unknown:
      return ERROR(TypeMismatch);
    case OpcodeType::Reg0:
      sprintf(buf, "%s", name);
      break;
    case OpcodeType::Reg0I:
      sprintf(buf, "%s %ld", name, val.arg1().arg);
      break;
    case OpcodeType::Reg1:
      sprintf(buf, "%s %s%ld", name, (val.arg1().is_const) ? "c" : "r",
              val.arg1().arg);
      break;
    case OpcodeType::Reg1I:
      sprintf(buf, "%s %s%ld %ld", name, (val.arg1().is_const) ? "c" : "r",
              val.arg1().arg, val.arg2().arg);
      break;
    case OpcodeType::Reg2:
      sprintf(buf, "%s %s%ld %s%ld", name, (val.arg1().is_const) ? "c" : "r",
              val.arg1().arg, (val.arg2().is_const) ? "c" : "r",
              val.arg2().arg);
      break;
    case OpcodeType::Reg2I:
      sprintf(buf, "%s %s%ld %s%ld %ld", name,
              (val.arg1().is_const) ? "c" : "r", val.arg1().arg,
              (val.arg2().is_const) ? "c" : "r", val.arg2().arg,
              val.arg3().arg);
      break;
    case OpcodeType::Reg3:
      sprintf(buf, "%s %s%ld %s%ld %s%ld", name,
              (val.arg1().is_const) ? "c" : "r", val.arg1().arg,
              (val.arg2().is_const) ? "c" : "r", val.arg2().arg,
              (val.arg3().is_const) ? "c" : "r", val.arg3().arg);
      break;
    case OpcodeType::Reg4:
      sprintf(buf, "%s %s%ld %s%ld %s%ld %s%ld", name,
              (val.arg1().is_const) ? "c" : "r", val.arg1().arg,
              (val.arg2().is_const) ? "c" : "r", val.arg2().arg,
              (val.arg3().is_const) ? "c" : "r", val.arg3().arg,
              (val.arg4().is_const) ? "c" : "r", val.arg4().arg);
      break;
  }
  res = TRY(res.concat(buf));

  res = TRY(res.concat(">"));
  return res;
}

Result<String> Writer::write_function(const Function& val) {
  auto name = TRY(val.name());
  if (name.is<Nil>()) {
    return TRY(String::create("#<function>"));
  }

  if (!name.is<Symbol>()) return ERROR(TypeMismatch);
  String name_str = TRY(write_symbol(*name.to<Symbol>()));

  String res = TRY(String::create("#<function "));
  res = TRY(res.concat(name_str));
  res = TRY(res.concat(">"));
  return res;
}

Result<String> Writer::write_stdlib_function(const StdlibFunction& val) {
  auto name = TRY(val.name());
  String name_str = TRY(write_symbol(name));

  String res = TRY(String::create("#<function "));
  res = TRY(res.concat(name_str));
  res = TRY(res.concat(">"));
  return res;
}

Result<String> Writer::write_module(const Module& val) {
  auto name = TRY(val.name());
  if (name.is<Nil>()) {
    return TRY(String::create("#<module>"));
  }

  if (!name.is<Symbol>()) return ERROR(TypeMismatch);
  String name_str = TRY(write_symbol(*name.to<Symbol>()));

  String res = TRY(String::create("#<module "));
  res = TRY(res.concat(name_str));
  res = TRY(res.concat(">"));
  return res;
}

Result<String> Writer::write_stack(const StackFrame& val) {
  return TRY(String::create("#<stack>"));
}

Result<String> Writer::write_error(const Error& val) {
  auto res = TRY(String::create("#<error:"));
  auto name = TRY(val.name());
  auto name_str = TRY(String::create(*name.to<Symbol>()));

  auto message = TRY(val.message());
  auto message_str = TRY(write_one(message));

  res = TRY(res.concat(name_str));
  res = TRY(res.concat(" "));
  res = TRY(res.concat(message_str));

  res = TRY(res.concat(">"));

  return res;
}

Result<String> Writer::write_continuation(const Continuation& val) {
  return TRY(String::create("#<continuation>"));
}

Result<String> Writer::write_task(const Task& val) {
  auto name = TRY(val.name());
  String name_str = TRY(write_symbol(name));
  String params_str = TRY(write_one(TRY(val.params())));

  String res = TRY(String::create("#<task "));
  res = TRY(res.concat(name_str));
  res = TRY(res.concat(" "));
  res = TRY(res.concat(params_str));
  res = TRY(res.concat(">"));
  return res;
}

Result<String> Writer::write_task_result(const TaskResult& val) {
  auto error = TRY(val.error());
  auto result = TRY(val.result());

  String res = TRY(String::create("#<task-result "));

  if (error.is<Nil>()) {
    res = TRY(res.concat(" :result "));
    String s = TRY(write_one(result));
    res = TRY(res.concat(s));
  } else {
    res = TRY(res.concat(" :error "));
    String s = TRY(write_one(error));
    res = TRY(res.concat(s));
  }

  res = TRY(res.concat(">"));
  return res;
}

Result<String> write_one(const Value& value) {
  auto w = Writer();
  return w.write_one(value);
}

Result<String> write_multiple(const Value& value) {
  auto w = Writer();
  return w.write_multiple(value);
}