symbol.h

Go to the documentation of this file.

 
#if !defined(VITA_SYMBOL_H)
#define      VITA_SYMBOL_H
 
#include <limits>
#include <string>
 
#include "kernel/vitafwd.h"
#include "kernel/common.h"
#include "kernel/core_interpreter.h"
 
namespace vita
{
using opcode_t = unsigned;
 
class symbol
{
public:
  enum format {c_format, cpp_format, mql_format, python_format, sup_format};
 
  explicit symbol(const std::string &, category_t = 0);
  virtual ~symbol() = default;
 
  virtual unsigned arity() const = 0;
  virtual bool input() const;
 
  [[nodiscard]] category_t category() const;
  [[nodiscard]] opcode_t opcode() const;
  [[nodiscard]] bool terminal() const;
 
  void category(category_t);
 
  [[nodiscard]] std::string name() const;
 
  virtual value_t eval(symbol_params &) const = 0;
 
  [[nodiscard]] double penalty(core_interpreter *) const;
 
  virtual bool is_valid() const;
 
private:
  // NVI template methods
  virtual double penalty_nvi(core_interpreter *) const;
 
  // Private data members
  static opcode_t opc_count_;
 
  opcode_t opcode_;
 
  category_t category_;
 
  std::string name_;
};
 
inline double symbol::penalty(core_interpreter *ci) const
{
  return penalty_nvi(ci);
}
 
inline category_t symbol::category() const
{
  return category_;
}
 
inline void symbol::category(category_t c)
{
  Expects(category_ == undefined_category);
  Expects(c != category_);
 
  category_ = c;
}
 
inline bool symbol::input() const
{
  return false;
}
 
inline opcode_t symbol::opcode() const
{
  return opcode_;
}
 
inline bool symbol::terminal() const
{
  return arity() == 0;
}
 
}  // namespace vita
 
#endif  // include guard