Environment.cpp

#include "Environment.h"

Environment::Environment() = default;
Environment::~Environment() = default;

void Environment::setEnclosing(Environment *enclosing) {
  if (this->enclosing) {
    throw std::runtime_error("Environment already set");
  }
  this->enclosing = enclosing;
}

Environment* Environment::ancestor(const unsigned int depth) {
  Environment* env = this;
  for (unsigned int i = 0; i < depth; i++) {
    env = env->ancestor(i);
    if (env == nullptr) {
      return nullptr;
    }
  }
  return env;
}

void Environment::clear() {
  this->enclosing = nullptr;
  values.clear();
}

void Environment::define(const std::string &name, const ObjPtr &value) {
  values[name] = value;
}

ObjPtr Environment::get(const Token &token) {
  const auto it = values.find(token.lexeme);
  if (it == values.end()) {
    if (enclosing != nullptr) {
      return enclosing->get(token);
    }
    throw RuntimeError(token, "Undefined variable '" + token.lexeme + "'.");
  }
  return it->second;
}

ObjPtr Environment::getAt(const unsigned int depth, const Token &token) {
  Environment* env = ancestor(depth);
  if (env == nullptr) {
    throw std::runtime_error("Environment unavailable depth.");
  }
  return env->get(token);
}

void Environment::assign(const Token &token, const ObjPtr &value) {
  const auto it = values.find(token.lexeme);
  if (it != values.end()) {
    it->second = value;
    return;
  }
  if (enclosing != nullptr) {
    enclosing->assign(token, value);
    return;
  }
  throw RuntimeError(token, "Undefined variable '" + token.lexeme + "'.");
}

void Environment::assignAt(const unsigned int depth, const Token &token, const ObjPtr &value) {
  Environment* env = ancestor(depth);
  if (env == nullptr) {
    throw std::runtime_error("Environment unavailable depth.");
  }
  env->assign(token, value);
}

size_t Environment::memoryUsage() const {
  return (sizeof(ObjPtr) + sizeof(Object)) * values.size();
}