eval.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "tcalc/builtins.hpp"
#include "tcalc/common.hpp"
#include "tcalc/error.hpp"
#include "tcalc/parser.hpp"
 
namespace tcalc {
 
class TCALC_PUBLIC EvalContext
{
public:
  constexpr static std::size_t MAX_CALL_DEPTH = 1000;
 
private:
  std::unordered_map<std::string, double> _vars;
  std::unordered_map<std::string, builtins::Function> _funcs;
 
  std::size_t _call_depth{ 0 };
 
public:
  EvalContext(std::unordered_map<std::string, double> vars,
              std::unordered_map<std::string, builtins::Function> funcs,
              std::size_t call_depth = 0)
    : _vars{ std::move(vars) }
    , _funcs{ std::move(funcs) }
    , _call_depth{ call_depth }
  {
  }
 
  EvalContext() = default;
  ~EvalContext() = default;
 
  [[nodiscard]] TCALC_INLINE auto& vars() noexcept { return _vars; }
 
  [[nodiscard]] TCALC_INLINE auto& funcs() noexcept { return _funcs; }
 
  error::Result<double> var(const std::string& name) const;
 
  TCALC_INLINE void var(const std::string& name, double value) noexcept
  {
    _vars[name] = value;
  }
 
  error::Result<builtins::Function> func(const std::string& name) const;
 
  TCALC_INLINE void func(const std::string& name,
                         builtins::Function func) noexcept
  {
    _funcs[name] = std::move(func);
  }
 
  [[nodiscard]] TCALC_INLINE auto call_depth() const noexcept
  {
    return _call_depth;
  }
 
  TCALC_INLINE void call_depth(std::size_t depth) { _call_depth = depth; }
 
  TCALC_INLINE void increment_call_depth() noexcept { ++_call_depth; }
 
  void update_with(const EvalContext& ctx);
};
 
class TCALC_PUBLIC Evaluator
{
private:
  EvalContext _ctx;
  ast::Parser _parser{};
 
public:
  explicit Evaluator(const EvalContext& ctx);
 
  Evaluator()
    : Evaluator{ EvalContext{ builtins::BUILTIN_VARIABLES,
                              builtins::BUILTIN_FUNCTIONS } }
  {
  }
 
  ~Evaluator() = default;
 
  [[nodiscard]] TCALC_INLINE auto& ctx() const noexcept { return _ctx; }
 
  error::Result<double> eval(std::string_view input);
 
  error::Result<std::vector<double>> eval_prog(std::string_view input);
};
 
}