formula_node.hpp

// Copyright Take Vos 2020.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "formula_post_process_context.hpp"
#include "formula_evaluation_context.hpp"
#include "../required.hpp"
#include "../parse_location.hpp"
#include "../datum.hpp"
#include "../exception.hpp"
#include <vector>
#include <memory>
#include <string>
 
namespace tt {
 
struct formula_node {
    using formula_vector = std::vector<std::unique_ptr<formula_node>>;
 
    parse_location location;
 
    formula_node(parse_location location) : location(location) {}
 
    virtual ~formula_node() {}
 
    virtual void post_process(formula_post_process_context &context) {}
 
    virtual void resolve_function_pointer(formula_post_process_context &context) {}
 
    virtual datum evaluate(formula_evaluation_context &context) const = 0;
 
    datum evaluate_without_output(formula_evaluation_context &context) const
    {
        context.disable_output();
        auto r = evaluate(context);
        context.enable_output();
        return r;
    }
 
    virtual datum &evaluate_lvalue(formula_evaluation_context &context) const
    {
        throw operation_error("{}: Expression is not a modifiable value.", location);
    }
 
    virtual bool has_evaluate_xvalue() const
    {
        return false;
    }
 
    virtual datum const &evaluate_xvalue(formula_evaluation_context const &context) const
    {
        throw operation_error("{}: Expression is not a xvalue.", location);
    }
 
    virtual datum &assign(formula_evaluation_context &context, datum const &rhs) const
    {
        return evaluate_lvalue(context) = rhs;
    }
 
    datum &assign_without_output(formula_evaluation_context &context, datum const &rhs) const
    {
        context.disable_output();
        auto &r = assign(context, rhs);
        context.enable_output();
        return r;
    }
 
    virtual datum call(formula_evaluation_context &context, datum::vector const &arguments) const
    {
        throw operation_error("{}: Expression is not callable.", location);
    }
 
    virtual std::string get_name() const
    {
        throw parse_error("{}: Expect a name got {})", location, *this);
    }
 
    virtual std::vector<std::string> get_name_and_argument_names() const
    {
        throw parse_error("{}: Expect a function definition got {})", location, *this);
    }
 
    virtual std::string string() const noexcept = 0;
 
    friend std::string to_string(formula_node const &rhs) noexcept
    {
        return rhs.string();
    }
 
    friend std::ostream &operator<<(std::ostream &lhs, formula_node const &rhs) noexcept
    {
        return lhs << to_string(rhs);
    }
};
 
template<typename CharT>
struct std::formatter<tt::formula_node, CharT> : std::formatter<string_view, CharT> {
    auto format(tt::formula_node const &t, auto &fc)
    {
        return std::formatter<string_view, CharT>::format(to_string(t), fc);
    }
};
 
} // namespace tt