interpret_environment.hh

// Copyright (c) 2019 ASMlover. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
//  * Redistributions of source code must retain the above copyright
//    notice, this list ofconditions and the following disclaimer.
//
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in
//    the documentation and/or other materialsprovided with the
//    distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
#pragma once

#include <memory>
#include <unordered_map>
#include "common.hh"
#include "token.hh"
#include "interpret_value.hh"

namespace loxcc::interpret {

class Environment;
using EnvironmentPtr = std::shared_ptr<Environment>;

class Environment final
  : private UnCopyable, public std::enable_shared_from_this<Environment> {
  EnvironmentPtr enclosing_{};
  std::unordered_map<str_t, Value> values_;

  EnvironmentPtr ancestor(int distance);
public:
  Environment(void) noexcept {}
  Environment(const EnvironmentPtr& enclosing) noexcept : enclosing_(enclosing) {}

  inline EnvironmentPtr get_enclosing(void) const {
    return enclosing_;
  }

  inline void define(const str_t& name, const Value& value) {
    values_[name] = value;
  }

  inline void define(const Token& name, const Value& value) {
    values_[name.literal()] = value;
  }

  inline const Value& get(const str_t& name) const {
    return get(Token::make_from_literal(name));
  }

  inline const Value& get_at(int distance, const str_t& name) {
    return ancestor(distance)->get(name);
  }

  inline const Value& get_at(int distance, const Token& name) {
    return ancestor(distance)->get(name);
  }

  inline void assign(const str_t& name, const Value& value) {
    assign(Token::make_from_literal(name), value);
  }

  inline void assign_at(int distance, const str_t& name, const Value& value) {
    ancestor(distance)->assign(name, value);
  }

  inline void assign_at(int distance, const Token& name, const Value& value) {
    ancestor(distance)->assign(name, value);
  }

  const Value& get(const Token& name) const;
  void assign(const Token& name, const Value& value);
};

}