eval.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <unordered_map>
#include <vector>
 
#include "tcalc/ast/binaryop.hpp"
#include "tcalc/ast/node.hpp"
#include "tcalc/builtins.hpp"
#include "tcalc/common.hpp"
#include "tcalc/eval.hpp"
#include "tcalc/visitor/base.hpp"
 
namespace tcalc::ast {
 
class TCALC_PUBLIC EvalVisitor : public BaseVisitor<double>
{
private:
  static double _double_eq(double a, double b);
 
  static bool _double_eq_bool(double a, double b);
 
  static double _double_noeq(double a, double b);
 
  static bool _double_noeq_bool(double a, double b);
 
  static double _double_forward(double a);
 
public:
  inline static const std::unordered_map<NodeType,
                                         std::function<double(double, double)>>
    BINOP_MAP = {
      { NodeType::BINARY_PLUS, std::plus<>() },
      { NodeType::BINARY_MINUS, std::minus<>() },
      { NodeType::BINARY_MULTIPLY, std::multiplies<>() },
      { NodeType::BINARY_DIVIDE, std::divides<>() },
      { NodeType::BINARY_EQUAL, _double_eq },
      { NodeType::BINARY_NOT_EQUAL, _double_noeq },
      { NodeType::BINARY_GREATER, std::greater<>() },
      { NodeType::BINARY_GREATER_EQUAL, std::greater_equal<>() },
      { NodeType::BINARY_LESS, std::less<>() },
      { NodeType::BINARY_LESS_EQUAL, std::less_equal<>() },
      { NodeType::BINARY_AND, std::logical_and<>() },
      { NodeType::BINARY_OR, std::logical_or<>() }
    }; 
  inline static const std::unordered_map<NodeType,
                                         std::function<double(double)>>
    UNARYOP_MAP = {
      { NodeType::UNARY_PLUS, _double_forward },
      { NodeType::UNARY_MINUS, std::negate<>() },
      { NodeType::UNARY_NOT, std::logical_not<>() }
    }; 
private:
  EvalContext* _ctx;
 
public:
  EvalVisitor(EvalContext& ctx)
    : _ctx{ &ctx }
  {
  }
 
  ~EvalVisitor() override = default;
 
  error::Result<double> visit_bin_op(NodePtr<BinaryOpNode>& node) override;
  error::Result<double> visit_unary_op(NodePtr<UnaryOpNode>& node) override;
  error::Result<double> visit_number(NodePtr<NumberNode>& node) override;
  error::Result<double> visit_varref(NodePtr<VarRefNode>& node) override;
  error::Result<double> visit_varassign(NodePtr<VarAssignNode>& node) override;
  error::Result<double> visit_fcall(NodePtr<FcallNode>& node) override;
  error::Result<double> visit_fdef(NodePtr<FdefNode>& node) override;
  error::Result<double> visit_if(NodePtr<IfNode>& node) override;
  error::Result<double> visit_import(NodePtr<ProgramImportNode>& node) override;
  error::Result<double> visit_program(NodePtr<ProgramNode>& node) override;
};
 
class TCALC_PUBLIC ProgramEvalVisitor : public BaseVisitor<std::vector<double>>
{
private:
  EvalContext* _ctx;
 
public:
  ProgramEvalVisitor(EvalContext& ctx)
    : _ctx{ &ctx }
  {
  }
 
  ~ProgramEvalVisitor() override = default;
 
  error::Result<std::vector<double>> visit_program(
    NodePtr<ProgramNode>& node) override;
};
 
}