PorygonLang/src/Evaluator/EvalValues/EvalValue.hpp

148 lines
4.4 KiB
C++
Raw Normal View History

#ifndef PORYGONLANG_EVALVALUE_HPP
#define PORYGONLANG_EVALVALUE_HPP
#include <string>
#include <sstream>
#include <memory>
#include "../../ScriptTypes/ScriptType.hpp"
2019-06-26 14:19:34 +00:00
#include "../EvaluationException.hpp"
namespace Porygon::Evaluation{
class EvalValue;
class Iterator;
}
#include "../Iterator/Iterator.hpp"
#include "../../Binder/BoundOperators.hpp"
2019-06-26 14:19:34 +00:00
namespace Porygon::Evaluation {
class EvalValue {
public:
EvalValue() = default;
virtual ~EvalValue() = default;
2019-07-25 15:23:54 +00:00
[[nodiscard]]
virtual TypeClass GetTypeClass() const = 0;
2019-07-25 15:23:54 +00:00
[[nodiscard]]
virtual bool operator==(const EvalValue *b) const = 0;
2019-07-25 15:23:54 +00:00
[[nodiscard]]
virtual bool operator!=(const EvalValue *b) const {
return !(this->operator==(b));
}
2019-07-25 15:23:54 +00:00
[[nodiscard]]
virtual EvalValue* Clone() const = 0;
2019-07-25 15:23:54 +00:00
[[nodiscard]]
virtual int64_t EvaluateInteger() const {
throw EvaluationException("Can't evaluate this EvalValue as integer.");
}
2019-07-25 15:23:54 +00:00
[[nodiscard]]
virtual double EvaluateFloat() const {
throw EvaluationException("Can't evaluate this EvalValue as float.");
}
2019-07-25 15:23:54 +00:00
[[nodiscard]]
virtual bool EvaluateBool() const {
throw EvaluationException("Can't evaluate this EvalValue as bool.");
}
2019-07-25 15:23:54 +00:00
[[nodiscard]]
virtual std::u16string EvaluateString() const {
throw EvaluationException("Can't evaluate this EvalValue as string.");
}
2019-07-25 15:23:54 +00:00
[[nodiscard]]
virtual std::size_t GetHashCode() const = 0;
2019-07-25 15:23:54 +00:00
[[nodiscard]]
virtual const EvalValue* IndexValue(const EvalValue *val) const {
throw EvaluationException("Can't index this EvalValue");
}
2019-07-25 15:23:54 +00:00
[[nodiscard]]
virtual const EvalValue* IndexValue(uint32_t hash) const {
throw EvaluationException("Can't index this EvalValue");
}
virtual void SetIndexValue(const EvalValue *key, const EvalValue* value) const {
throw EvaluationException("Can't index this EvalValue");
}
2019-06-26 14:19:34 +00:00
2019-07-25 15:23:54 +00:00
[[nodiscard]]
2019-06-26 14:19:34 +00:00
virtual Iterator * GetKeyIterator() const{
throw EvaluationException("Can't iterate over this EvalValue");
}
[[nodiscard]]
virtual EvalValue* BinaryOperation(Binder::BoundBinaryOperation operation, const EvalValue* b) const{
throw EvaluationException("Binary operations are not implemented for this type.");
}
[[nodiscard]]
virtual EvalValue* UnaryOperation(Binder::BoundUnaryOperation operation) const{
throw EvaluationException("Unary operations are not implemented for this type.");
}
};
2019-06-09 18:15:09 +00:00
class BooleanEvalValue : public EvalValue {
const bool _value;
public:
explicit BooleanEvalValue(bool val)
: _value(val) {
}
2019-07-25 15:23:54 +00:00
[[nodiscard]]
inline EvalValue* Clone() const final {
return new BooleanEvalValue(_value);
}
2019-07-25 15:23:54 +00:00
[[nodiscard]]
inline TypeClass GetTypeClass() const final {
return TypeClass::Bool;
}
2019-07-25 15:23:54 +00:00
[[nodiscard]]
inline bool EvaluateBool() const final {
return _value;
}
2019-07-25 15:23:54 +00:00
[[nodiscard]]
bool operator==(const EvalValue *b) const final {
if (b->GetTypeClass() != TypeClass::Bool)
return false;
return this->EvaluateBool() == b->EvaluateBool();
};
2019-07-25 15:23:54 +00:00
[[nodiscard]]
inline std::size_t GetHashCode() const final {
return _value;
}
[[nodiscard]]
inline EvalValue* BinaryOperation(Binder::BoundBinaryOperation operation, const EvalValue* b) const final{
auto bVal = b -> EvaluateBool();
switch (operation){
case Binder::BoundBinaryOperation::LogicalAnd: return new BooleanEvalValue(_value && bVal);
case Binder::BoundBinaryOperation::LogicalOr: return new BooleanEvalValue(_value || bVal);
default:
throw;
}
}
[[nodiscard]]
EvalValue* UnaryOperation(Binder::BoundUnaryOperation operation) const final{
switch (operation){
case Binder::BoundUnaryOperation::LogicalNegation: return new BooleanEvalValue(!_value);
default: throw;
}
}
};
}
#endif //PORYGONLANG_EVALVALUE_HPP