From 21d3329c55109b8fad7601d9c6a6a13d16021160 Mon Sep 17 00:00:00 2001 From: Deukhoofd Date: Mon, 17 Jun 2019 17:43:54 +0200 Subject: [PATCH] Mark evalValues as const --- src/Binder/Binder.cpp | 2 +- .../BoundExpressions/BoundExpression.hpp | 25 +++--- .../BoundExpressions/BoundTableExpression.hpp | 4 +- src/Evaluator/BinaryEvaluation.cpp | 40 ++++----- src/Evaluator/EvalValues/EvalValue.hpp | 32 ++++---- src/Evaluator/EvalValues/NumericEvalValue.cpp | 82 +++++++++---------- src/Evaluator/EvalValues/NumericEvalValue.hpp | 60 +++++++------- .../EvalValues/ScriptFunctionEvalValue.hpp | 45 +++++----- src/Evaluator/EvalValues/StringEvalValue.hpp | 10 +-- src/Evaluator/EvalValues/TableEvalValue.hpp | 16 ++-- src/Evaluator/Evaluator.cpp | 31 +++---- src/Evaluator/Evaluator.hpp | 41 +++++----- src/Evaluator/UnaryEvaluation.cpp | 4 +- src/UserData/UserDataValue.hpp | 27 +++--- 14 files changed, 204 insertions(+), 215 deletions(-) diff --git a/src/Binder/Binder.cpp b/src/Binder/Binder.cpp index cb6b92a..d98bebf 100644 --- a/src/Binder/Binder.cpp +++ b/src/Binder/Binder.cpp @@ -490,7 +490,7 @@ BoundExpression* Binder::BindPeriodIndexExpression(const PeriodIndexExpression* BoundExpression* Binder::BindNumericalTableExpression(const ParsedNumericalTableExpression* expression){ auto expressions = expression->GetExpressions(); - auto boundExpressions = vector(expressions-> size()); + auto boundExpressions = vector(expressions-> size()); shared_ptr valueType = nullptr; if (!boundExpressions.empty()){ boundExpressions[0] = this -> BindExpression(expressions -> at(0)); diff --git a/src/Binder/BoundExpressions/BoundExpression.hpp b/src/Binder/BoundExpressions/BoundExpression.hpp index 50522e5..16c10f2 100644 --- a/src/Binder/BoundExpressions/BoundExpression.hpp +++ b/src/Binder/BoundExpressions/BoundExpression.hpp @@ -1,4 +1,3 @@ - #ifndef PORYGONLANG_BOUNDEXPRESSION_HPP #define PORYGONLANG_BOUNDEXPRESSION_HPP @@ -107,7 +106,7 @@ public: class BoundLiteralStringExpression : public BoundExpression{ const u16string _value; public: - BoundLiteralStringExpression(u16string value, unsigned int start, unsigned int length) + BoundLiteralStringExpression(const u16string& value, unsigned int start, unsigned int length) : BoundExpression(start, length, make_shared(true, HashedString::ConstHash(value.c_str()))), _value(value) { @@ -203,7 +202,7 @@ class BoundUnaryExpression : public BoundExpression { const BoundUnaryOperation _operation; public: BoundUnaryExpression(BoundExpression* operand, BoundUnaryOperation op, shared_ptr result, unsigned int start, unsigned int length) - : BoundExpression(start, length, result), + : BoundExpression(start, length, std::move(result)), _operand(operand), _operation(op) { @@ -232,7 +231,7 @@ class BoundFunctionCallExpression : public BoundExpression { public: BoundFunctionCallExpression(BoundExpression *functionExpression, vector parameters, shared_ptr result, unsigned int start, unsigned int length) - : BoundExpression(start, length, result), _functionExpression(functionExpression), _parameters(std::move(parameters)) {} + : BoundExpression(start, length, std::move(result)), _functionExpression(functionExpression), _parameters(std::move(parameters)) {} ~BoundFunctionCallExpression() final{ delete _functionExpression; @@ -255,8 +254,8 @@ public: }; class BoundIndexExpression : public BoundExpression { - BoundExpression* _indexableExpression; - BoundExpression* _indexExpression; + const BoundExpression* _indexableExpression; + const BoundExpression* _indexExpression; public: BoundIndexExpression(BoundExpression* indexableExpression, BoundExpression* indexExpression, shared_ptr result, unsigned int start, unsigned int length) @@ -271,18 +270,18 @@ public: return BoundExpressionKind ::Index; } - BoundExpression* GetIndexableExpression() const{ + const BoundExpression* GetIndexableExpression() const{ return _indexableExpression; } - BoundExpression* GetIndexExpression() const{ + const BoundExpression* GetIndexExpression() const{ return _indexExpression; } }; class BoundPeriodIndexExpression : public BoundExpression { - BoundExpression* _indexableExpression; - HashedString _index; + const BoundExpression* _indexableExpression; + const HashedString _index; public: BoundPeriodIndexExpression(BoundExpression* indexableExpression, HashedString index, shared_ptr result, unsigned int start, unsigned int length) @@ -306,9 +305,9 @@ public: }; class BoundNumericalTableExpression : public BoundExpression{ - const vector _expressions; + const vector _expressions; public: - BoundNumericalTableExpression(vector expressions, shared_ptr type, unsigned int start, unsigned int length) + BoundNumericalTableExpression(vector expressions, shared_ptr type, unsigned int start, unsigned int length) : BoundExpression(start, length, std::move(type)), _expressions(std::move(expressions)) {} @@ -323,7 +322,7 @@ public: return BoundExpressionKind ::NumericalTable; } - const vector* GetExpressions() const{ + const vector* GetExpressions() const{ return &_expressions; } }; diff --git a/src/Binder/BoundExpressions/BoundTableExpression.hpp b/src/Binder/BoundExpressions/BoundTableExpression.hpp index 52f6f17..c9be54e 100644 --- a/src/Binder/BoundExpressions/BoundTableExpression.hpp +++ b/src/Binder/BoundExpressions/BoundTableExpression.hpp @@ -7,7 +7,7 @@ #include "../BoundStatements/BoundStatement.hpp" class BoundTableExpression : public BoundExpression{ - BoundBlockStatement* _block; + const BoundBlockStatement* _block; public: BoundTableExpression(BoundBlockStatement* block, shared_ptr type, unsigned int start, unsigned int length) : BoundExpression(start, length, std::move(type)){ @@ -22,7 +22,7 @@ public: return BoundExpressionKind ::Table; } - BoundBlockStatement* GetBlock(){ + const BoundBlockStatement* GetBlock() const { return _block; } }; diff --git a/src/Evaluator/BinaryEvaluation.cpp b/src/Evaluator/BinaryEvaluation.cpp index e32d18d..6de1fd5 100644 --- a/src/Evaluator/BinaryEvaluation.cpp +++ b/src/Evaluator/BinaryEvaluation.cpp @@ -5,31 +5,25 @@ #include "EvalValues/NumericEvalValue.hpp" #include "EvalValues/StringEvalValue.hpp" -shared_ptr Evaluator::EvaluateIntegerBinary(const BoundBinaryExpression *expression) { +const shared_ptr Evaluator::EvaluateIntegerBinary(const BoundBinaryExpression *expression) { auto leftValue = this -> EvaluateIntegerExpression(expression->GetLeft()); auto rightValue = this -> EvaluateIntegerExpression(expression->GetRight()); - NumericEvalValue* result; switch (expression->GetOperation()){ case BoundBinaryOperation ::Addition: - result = leftValue.get() -> operator+ (rightValue.get()); - break; + return leftValue.get() -> operator+ (rightValue); case BoundBinaryOperation::Subtraction: - result = leftValue.get() -> operator- (rightValue.get()); - break; + return leftValue.get() -> operator- (rightValue); case BoundBinaryOperation::Multiplication: - result = leftValue.get() -> operator* (rightValue.get()); - break; + return leftValue.get() -> operator* (rightValue); case BoundBinaryOperation::Division: - result = leftValue.get() -> operator/ (rightValue.get()); - break; + return leftValue.get() -> operator/ (rightValue); default: throw EvaluationException("Can't evaluate operation to numeric"); } - return shared_ptr(result); } -shared_ptr Evaluator::EvaluateBooleanBinary(const BoundBinaryExpression* expression){ +const shared_ptr Evaluator::EvaluateBooleanBinary(const BoundBinaryExpression *expression){ switch (expression->GetOperation()){ case BoundBinaryOperation::Equality: { @@ -49,29 +43,25 @@ shared_ptr Evaluator::EvaluateBooleanBinary(const BoundBinaryE { auto leftValue = this -> EvaluateIntegerExpression(expression->GetLeft()); auto rightValue = this -> EvaluateIntegerExpression(expression->GetRight()); - BooleanEvalValue* b = leftValue->operator<(rightValue.get()); - return shared_ptr(b); + return leftValue->operator<(rightValue); } case BoundBinaryOperation ::LessThanEquals: { auto leftValue = this -> EvaluateIntegerExpression(expression->GetLeft()); auto rightValue = this -> EvaluateIntegerExpression(expression->GetRight()); - BooleanEvalValue* b = leftValue->operator<=(rightValue.get()); - return shared_ptr(b); + return leftValue->operator<=(rightValue); } case BoundBinaryOperation ::GreaterThan: { auto leftValue = this -> EvaluateIntegerExpression(expression->GetLeft()); auto rightValue = this -> EvaluateIntegerExpression(expression->GetRight()); - BooleanEvalValue* b = leftValue->operator>(rightValue.get()); - return shared_ptr(b); + return leftValue->operator>(rightValue); } case BoundBinaryOperation ::GreaterThanEquals: { auto leftValue = this -> EvaluateIntegerExpression(expression->GetLeft()); auto rightValue = this -> EvaluateIntegerExpression(expression->GetRight()); - BooleanEvalValue* b = leftValue->operator>=(rightValue.get()); - return shared_ptr(b); + return leftValue->operator>=(rightValue); } case BoundBinaryOperation::LogicalAnd: @@ -93,13 +83,13 @@ shared_ptr Evaluator::EvaluateBooleanBinary(const BoundBinaryE } } -shared_ptr Evaluator::EvaluateStringBinary(const BoundBinaryExpression* expression){ +const shared_ptr Evaluator::EvaluateStringBinary(const BoundBinaryExpression *expression){ if (expression->GetOperation() != BoundBinaryOperation::Concatenation) throw; - std::basic_ostringstream strs; + std::basic_ostringstream stringStream; auto left = this -> EvaluateStringExpression(expression->GetLeft()); - strs << *left->EvaluateString(); + stringStream << *left->EvaluateString(); auto right = this -> EvaluateExpression(expression->GetRight()); - strs << *right->EvaluateString(); - return make_shared(strs.str()); + stringStream << *right->EvaluateString(); + return make_shared(stringStream.str()); } \ No newline at end of file diff --git a/src/Evaluator/EvalValues/EvalValue.hpp b/src/Evaluator/EvalValues/EvalValue.hpp index fd0f5a6..7867588 100644 --- a/src/Evaluator/EvalValues/EvalValue.hpp +++ b/src/Evaluator/EvalValues/EvalValue.hpp @@ -12,40 +12,40 @@ class EvalValue{ public: EvalValue() = default; virtual ~EvalValue() = default; - virtual const TypeClass GetTypeClass() = 0; + virtual const TypeClass GetTypeClass() const = 0; - virtual bool operator ==(EvalValue* b) = 0; + virtual const bool operator ==(EvalValue* b) const = 0; - virtual bool operator !=(EvalValue*b){ + virtual const bool operator !=(EvalValue*b) const{ return ! (this->operator==(b)); } - virtual shared_ptr Clone() = 0; + virtual const shared_ptr Clone() const = 0; - virtual long EvaluateInteger() const{ + virtual const long EvaluateInteger() const{ throw EvaluationException("Can't evaluate this EvalValue as integer."); } - virtual double EvaluateFloat() const{ + virtual const double EvaluateFloat() const{ throw EvaluationException("Can't evaluate this EvalValue as float."); } - virtual bool EvaluateBool() const{ + virtual const bool EvaluateBool() const{ throw EvaluationException("Can't evaluate this EvalValue as bool."); } virtual const std::u16string* EvaluateString() const { throw EvaluationException("Can't evaluate this EvalValue as string."); } - virtual std::size_t GetHashCode() = 0; + virtual const std::size_t GetHashCode() const = 0; - virtual shared_ptr IndexValue(EvalValue* val){ + virtual const shared_ptr IndexValue(EvalValue* val) const{ throw EvaluationException("Can't index this EvalValue"); } - virtual shared_ptr IndexValue(uint32_t hash){ + virtual const shared_ptr IndexValue(uint32_t hash) const{ throw EvaluationException("Can't index this EvalValue"); } - virtual void SetIndexValue(EvalValue *key, shared_ptr value){ + virtual void SetIndexValue(EvalValue *key, const shared_ptr& value) const{ throw EvaluationException("Can't index this EvalValue"); } }; @@ -58,25 +58,25 @@ public: { } - shared_ptr Clone() final{ + const shared_ptr Clone() const final{ return make_shared(_value); } - const TypeClass GetTypeClass() final{ + const TypeClass GetTypeClass() const final{ return TypeClass ::Bool; } - bool EvaluateBool() const final{ + const bool EvaluateBool() const final{ return _value; } - bool operator ==(EvalValue* b) final{ + const bool operator ==(EvalValue* b) const final{ if (b->GetTypeClass() != TypeClass::Bool) return false; return this->EvaluateBool() == b->EvaluateBool(); }; - std::size_t GetHashCode() final{ + const std::size_t GetHashCode() const final{ return _value; } }; diff --git a/src/Evaluator/EvalValues/NumericEvalValue.cpp b/src/Evaluator/EvalValues/NumericEvalValue.cpp index 8cf2afa..65ff6e9 100644 --- a/src/Evaluator/EvalValues/NumericEvalValue.cpp +++ b/src/Evaluator/EvalValues/NumericEvalValue.cpp @@ -1,71 +1,71 @@ #include "NumericEvalValue.hpp" -NumericEvalValue *NumericEvalValue::operator+(NumericEvalValue *b) { +const shared_ptr NumericEvalValue::operator+(const shared_ptr& b) const { if (this->IsFloat()){ if (b->IsFloat()){ - return new FloatEvalValue(this->GetFloatValue() + b->GetFloatValue()); + return make_shared(this->GetFloatValue() + b->GetFloatValue()); } else{ - return new FloatEvalValue(this->GetFloatValue() + b->GetIntegerValue()); + return make_shared(this->GetFloatValue() + b->GetIntegerValue()); } } else { if (b->IsFloat()){ - return new FloatEvalValue(this->GetIntegerValue() + b->GetFloatValue()); + return make_shared(this->GetIntegerValue() + b->GetFloatValue()); } else{ - return new IntegerEvalValue(this->GetIntegerValue() + b->GetIntegerValue()); + return make_shared(this->GetIntegerValue() + b->GetIntegerValue()); } } } -NumericEvalValue *NumericEvalValue::operator-(NumericEvalValue *b) { +const shared_ptr NumericEvalValue::operator-(const shared_ptr& b) const { if (this->IsFloat()){ if (b->IsFloat()){ - return new FloatEvalValue(this->GetFloatValue() - b->GetFloatValue()); + return make_shared(this->GetFloatValue() - b->GetFloatValue()); } else{ - return new FloatEvalValue(this->GetFloatValue() - b->GetIntegerValue()); + return make_shared(this->GetFloatValue() - b->GetIntegerValue()); } } else { if (b->IsFloat()){ - return new FloatEvalValue(this->GetIntegerValue() - b->GetFloatValue()); + return make_shared(this->GetIntegerValue() - b->GetFloatValue()); } else{ - return new IntegerEvalValue(this->GetIntegerValue() - b->GetIntegerValue()); + return make_shared(this->GetIntegerValue() - b->GetIntegerValue()); } } } -NumericEvalValue *NumericEvalValue::operator*(NumericEvalValue *b) { +const shared_ptr NumericEvalValue::operator*(const shared_ptr& b) const { if (this->IsFloat()){ if (b->IsFloat()){ - return new FloatEvalValue(this->GetFloatValue() * b->GetFloatValue()); + return make_shared(this->GetFloatValue() * b->GetFloatValue()); } else{ - return new FloatEvalValue(this->GetFloatValue() * b->GetIntegerValue()); + return make_shared(this->GetFloatValue() * b->GetIntegerValue()); } } else { if (b->IsFloat()){ - return new FloatEvalValue(this->GetIntegerValue() * b->GetFloatValue()); + return make_shared(this->GetIntegerValue() * b->GetFloatValue()); } else{ - return new IntegerEvalValue(this->GetIntegerValue() * b->GetIntegerValue()); + return make_shared(this->GetIntegerValue() * b->GetIntegerValue()); } } } -NumericEvalValue *NumericEvalValue::operator/(NumericEvalValue *b) { +const shared_ptr NumericEvalValue::operator/(const shared_ptr& b) const { if (this->IsFloat()){ if (b->IsFloat()){ - return new FloatEvalValue(this->GetFloatValue() / b->GetFloatValue()); + return make_shared(this->GetFloatValue() / b->GetFloatValue()); } else{ - return new FloatEvalValue(this->GetFloatValue() / b->GetIntegerValue()); + return make_shared(this->GetFloatValue() / b->GetIntegerValue()); } } else { if (b->IsFloat()){ - return new FloatEvalValue(this->GetIntegerValue() / b->GetFloatValue()); + return make_shared(this->GetIntegerValue() / b->GetFloatValue()); } else{ - return new IntegerEvalValue(this->GetIntegerValue() / b->GetIntegerValue()); + return make_shared(this->GetIntegerValue() / b->GetIntegerValue()); } } } -bool NumericEvalValue::operator==(EvalValue *b) { +const bool NumericEvalValue::operator==(EvalValue *b) const { if (b->GetTypeClass() != TypeClass::Number) return false; auto numVal = (NumericEvalValue*)b; @@ -79,66 +79,66 @@ bool NumericEvalValue::operator==(EvalValue *b) { } } -BooleanEvalValue *NumericEvalValue::operator<(NumericEvalValue *b) { +const shared_ptr NumericEvalValue::operator<(const shared_ptr& b) const { if (this->IsFloat()){ if (b->IsFloat()){ - return new BooleanEvalValue(this->GetFloatValue() < b->GetFloatValue()); + return make_shared(this->GetFloatValue() < b->GetFloatValue()); } else{ - return new BooleanEvalValue(this->GetFloatValue() < b->GetIntegerValue()); + return make_shared(this->GetFloatValue() < b->GetIntegerValue()); } } else { if (b->IsFloat()){ - return new BooleanEvalValue(this->GetIntegerValue() < b->GetFloatValue()); + return make_shared(this->GetIntegerValue() < b->GetFloatValue()); } else{ - return new BooleanEvalValue(this->GetIntegerValue() < b->GetIntegerValue()); + return make_shared(this->GetIntegerValue() < b->GetIntegerValue()); } } } -BooleanEvalValue *NumericEvalValue::operator<=(NumericEvalValue *b) { +const shared_ptr NumericEvalValue::operator<=(const shared_ptr& b) const { if (this->IsFloat()){ if (b->IsFloat()){ - return new BooleanEvalValue(this->GetFloatValue() <= b->GetFloatValue()); + return make_shared(this->GetFloatValue() <= b->GetFloatValue()); } else{ - return new BooleanEvalValue(this->GetFloatValue() <= b->GetIntegerValue()); + return make_shared(this->GetFloatValue() <= b->GetIntegerValue()); } } else { if (b->IsFloat()){ - return new BooleanEvalValue(this->GetIntegerValue() <= b->GetFloatValue()); + return make_shared(this->GetIntegerValue() <= b->GetFloatValue()); } else{ - return new BooleanEvalValue(this->GetIntegerValue() <= b->GetIntegerValue()); + return make_shared(this->GetIntegerValue() <= b->GetIntegerValue()); } } } -BooleanEvalValue *NumericEvalValue::operator>(NumericEvalValue *b) { +const shared_ptr NumericEvalValue::operator>(const shared_ptr& b) const { if (this->IsFloat()){ if (b->IsFloat()){ - return new BooleanEvalValue(this->GetFloatValue() > b->GetFloatValue()); + return make_shared(this->GetFloatValue() > b->GetFloatValue()); } else{ - return new BooleanEvalValue(this->GetFloatValue() > b->GetIntegerValue()); + return make_shared(this->GetFloatValue() > b->GetIntegerValue()); } } else { if (b->IsFloat()){ - return new BooleanEvalValue(this->GetIntegerValue() > b->GetFloatValue()); + return make_shared(this->GetIntegerValue() > b->GetFloatValue()); } else{ - return new BooleanEvalValue(this->GetIntegerValue() > b->GetIntegerValue()); + return make_shared(this->GetIntegerValue() > b->GetIntegerValue()); } } } -BooleanEvalValue *NumericEvalValue::operator>=(NumericEvalValue *b) { +const shared_ptr NumericEvalValue::operator>=(const shared_ptr& b) const { if (this->IsFloat()){ if (b->IsFloat()){ - return new BooleanEvalValue(this->GetFloatValue() >= b->GetFloatValue()); + return make_shared(this->GetFloatValue() >= b->GetFloatValue()); } else{ - return new BooleanEvalValue(this->GetFloatValue() >= b->GetIntegerValue()); + return make_shared(this->GetFloatValue() >= b->GetIntegerValue()); } } else { if (b->IsFloat()){ - return new BooleanEvalValue(this->GetIntegerValue() >= b->GetFloatValue()); + return make_shared(this->GetIntegerValue() >= b->GetFloatValue()); } else{ - return new BooleanEvalValue(this->GetIntegerValue() >= b->GetIntegerValue()); + return make_shared(this->GetIntegerValue() >= b->GetIntegerValue()); } } } diff --git a/src/Evaluator/EvalValues/NumericEvalValue.hpp b/src/Evaluator/EvalValues/NumericEvalValue.hpp index 651f363..5ed75cf 100644 --- a/src/Evaluator/EvalValues/NumericEvalValue.hpp +++ b/src/Evaluator/EvalValues/NumericEvalValue.hpp @@ -7,73 +7,71 @@ class NumericEvalValue : public EvalValue{ - virtual long GetIntegerValue() = 0; - virtual double GetFloatValue() = 0; + virtual const long GetIntegerValue() const = 0; + virtual const double GetFloatValue() const = 0; public: - virtual const bool IsFloat() = 0; + virtual const bool IsFloat() const = 0; - const TypeClass GetTypeClass() final{ + const TypeClass GetTypeClass() const final{ return TypeClass ::Number; } - NumericEvalValue* operator +(NumericEvalValue* b); - NumericEvalValue* operator -(NumericEvalValue* b); - NumericEvalValue* operator *(NumericEvalValue* b); - NumericEvalValue* operator /(NumericEvalValue* b); - BooleanEvalValue* operator <(NumericEvalValue* b); - BooleanEvalValue* operator <=(NumericEvalValue* b); - BooleanEvalValue* operator >(NumericEvalValue* b); - BooleanEvalValue* operator >=(NumericEvalValue* b); - bool operator ==(EvalValue* b) final; + const shared_ptr operator +(const shared_ptr& b) const; + const shared_ptr operator -(const shared_ptr& b) const ; + const shared_ptr operator *(const shared_ptr& b) const ; + const shared_ptr operator /(const shared_ptr& b) const ; + const shared_ptr operator <(const shared_ptr& b) const ; + const shared_ptr operator <=(const shared_ptr& b)const ; + const shared_ptr operator >(const shared_ptr& b) const ; + const shared_ptr operator >=(const shared_ptr& b) const ; + const bool operator ==(EvalValue* b) const final; }; class IntegerEvalValue : public NumericEvalValue{ - long _value; - long GetIntegerValue() final{return _value;} - double GetFloatValue() final{ throw EvaluationException("Attempting to retrieve float from int eval value."); } + const long _value; + const long GetIntegerValue() const final{return _value;} + const double GetFloatValue() const final{ throw EvaluationException("Attempting to retrieve float from int eval value."); } public: - explicit IntegerEvalValue(long value){ - _value = value; + explicit IntegerEvalValue(long value) :_value(value){ } - const bool IsFloat() final{ + const bool IsFloat() const final{ return false; } - long EvaluateInteger() const final{ + const long EvaluateInteger() const final{ return _value; } - shared_ptr Clone() final{ + const shared_ptr Clone() const final{ return make_shared(_value); } - std::size_t GetHashCode() final{ + const std::size_t GetHashCode() const final{ return std::hash{}(_value); } }; class FloatEvalValue : public NumericEvalValue{ - double _value; - long GetIntegerValue() final{ throw EvaluationException("Attempting to retrieve float from int eval value."); } - double GetFloatValue() final{return _value;} + const double _value; + const long GetIntegerValue() const final{ throw EvaluationException("Attempting to retrieve float from int eval value."); } + const double GetFloatValue() const final{return _value;} public: - explicit FloatEvalValue(double value){ - _value = value; + explicit FloatEvalValue(double value) :_value(value){ } - const bool IsFloat() final{ + const bool IsFloat() const final{ return true; } - double EvaluateFloat() const final{ + const double EvaluateFloat() const final{ return _value; } - shared_ptr Clone() final{ + const shared_ptr Clone() const final{ return make_shared(_value); } - std::size_t GetHashCode() final{ + const std::size_t GetHashCode() const final{ return std::hash{}(_value); } }; diff --git a/src/Evaluator/EvalValues/ScriptFunctionEvalValue.hpp b/src/Evaluator/EvalValues/ScriptFunctionEvalValue.hpp index 8d503ba..318375b 100644 --- a/src/Evaluator/EvalValues/ScriptFunctionEvalValue.hpp +++ b/src/Evaluator/EvalValues/ScriptFunctionEvalValue.hpp @@ -1,7 +1,5 @@ #include -#include - #ifndef PORYGONLANG_SCRIPTFUNCTIONEVALVALUE_HPP #define PORYGONLANG_SCRIPTFUNCTIONEVALVALUE_HPP @@ -15,57 +13,58 @@ class ScriptFunctionEvalValue : public EvalValue{ - std::shared_ptr _innerBlock; - std::shared_ptr _type; - std::shared_ptr _scope; - std::size_t _hash; - explicit ScriptFunctionEvalValue(std::shared_ptr innerBlock, std::shared_ptr scope, + const std::shared_ptr _innerBlock; + const std::shared_ptr _type; + const std::shared_ptr _scope; + const std::size_t _hash; + explicit ScriptFunctionEvalValue(std::shared_ptr innerBlock, std::shared_ptr scope, std::shared_ptr type, size_t hash) - : _type(std::move(type)) + : _type(std::move(type)), + _innerBlock(std::move(innerBlock)), + _scope(std::move(scope)), + _hash(hash) { - _innerBlock = std::move(innerBlock); - _scope = std::move(scope); - _hash = hash; } public: - explicit ScriptFunctionEvalValue(std::shared_ptr innerBlock, std::shared_ptr scope, + explicit ScriptFunctionEvalValue(std::shared_ptr innerBlock, std::shared_ptr scope, std::shared_ptr type) - : _type(std::move(type)) + : _type(std::move(type)), + _innerBlock(std::move(innerBlock)), + _scope(std::move(scope)), + _hash(rand()) { - _innerBlock = std::move(innerBlock); - _scope = std::move(scope); - _hash = rand(); } - std::shared_ptr GetType() const{ + const std::shared_ptr GetType() const{ return _type; } - const TypeClass GetTypeClass() final{ + const TypeClass GetTypeClass() const final{ return TypeClass ::Function; } - shared_ptr Clone() final{ + const shared_ptr Clone() const final{ + // We don't run make_shared here as it can't call private constructors return shared_ptr(new ScriptFunctionEvalValue(_innerBlock, _scope, _type, _hash)); } - bool operator ==(EvalValue* b) final{ + const bool operator ==(EvalValue* b) const final{ if (b->GetTypeClass() != TypeClass::Function) return false; return this->_hash == ((ScriptFunctionEvalValue*)b)->_hash; }; - std::shared_ptr GetInnerBlock() const{ + const std::shared_ptr& GetInnerBlock() const{ return _innerBlock; } - std::size_t GetHashCode() final{ + const std::size_t GetHashCode() const final{ return _hash; } - std::shared_ptr GetScope() const{ + const std::shared_ptr& GetScope() const{ return _scope; } }; diff --git a/src/Evaluator/EvalValues/StringEvalValue.hpp b/src/Evaluator/EvalValues/StringEvalValue.hpp index 27f8898..51a22e4 100644 --- a/src/Evaluator/EvalValues/StringEvalValue.hpp +++ b/src/Evaluator/EvalValues/StringEvalValue.hpp @@ -17,11 +17,11 @@ public: _hash = HashedString::ConstHash (_value.c_str()); } - const TypeClass GetTypeClass() final{ + const TypeClass GetTypeClass() const final{ return TypeClass ::String; } - bool operator ==(EvalValue* b) final{ + const bool operator ==(EvalValue* b) const final{ if (b->GetTypeClass() != TypeClass::String) return false; return this->_hash == b->GetHashCode(); @@ -31,17 +31,17 @@ public: return &_value; } - shared_ptr Clone() final{ + const shared_ptr Clone() const final{ return make_shared(_value); } - shared_ptr IndexValue(EvalValue* val) final{ + const shared_ptr IndexValue(EvalValue* val) const final{ // Porygon is 1-indexed, so we convert to that. auto l = val->EvaluateInteger() - 1; return make_shared(u16string(1, _value[l])); } - std::size_t GetHashCode() final{ + const std::size_t GetHashCode() const final{ return _hash; } }; diff --git a/src/Evaluator/EvalValues/TableEvalValue.hpp b/src/Evaluator/EvalValues/TableEvalValue.hpp index a3628a8..b35c9b0 100644 --- a/src/Evaluator/EvalValues/TableEvalValue.hpp +++ b/src/Evaluator/EvalValues/TableEvalValue.hpp @@ -20,37 +20,37 @@ public: _hash = rand(); } - const TypeClass GetTypeClass() final{ + const TypeClass GetTypeClass() const final{ return TypeClass ::Table; } - size_t GetHashCode() final{ + const size_t GetHashCode() const final{ return _hash; } - bool operator ==(EvalValue* b) final{ + const bool operator ==(EvalValue* b) const final{ return this -> _hash == b->GetHashCode(); } - shared_ptr Clone() final{ + const shared_ptr Clone() const final{ return shared_ptr(new TableEvalValue(_table, _hash)); } - shared_ptr IndexValue(EvalValue* val) final{ + const shared_ptr IndexValue(EvalValue* val) const final{ auto hash = val->GetHashCode(); return this -> _table->at(hash); } - shared_ptr IndexValue(uint32_t hash) final{ + const shared_ptr IndexValue(uint32_t hash) const final{ return this -> _table->at(hash); } - shared_ptr IndexValue(const char* val){ + const shared_ptr IndexValue(const char* val) const { auto hash = HashedString::ConstHash(val); return this -> _table -> at(hash); } - void SetIndexValue(EvalValue *key, shared_ptr value) final{ + void SetIndexValue(EvalValue *key, const shared_ptr& value) const final{ auto hash = key->GetHashCode(); this -> _table->at(hash) = value; } diff --git a/src/Evaluator/Evaluator.cpp b/src/Evaluator/Evaluator.cpp index cdd10b6..db0d53e 100644 --- a/src/Evaluator/Evaluator.cpp +++ b/src/Evaluator/Evaluator.cpp @@ -104,7 +104,7 @@ void Evaluator::EvaluateConditionalStatement(const BoundConditionalStatement *st } } -shared_ptr Evaluator::EvaluateExpression(const BoundExpression *expression) { +const shared_ptr Evaluator::EvaluateExpression(const BoundExpression *expression) { auto type = expression -> GetType(); switch (type->GetClass()){ case TypeClass ::Number: return this -> EvaluateIntegerExpression(expression); @@ -118,7 +118,7 @@ shared_ptr Evaluator::EvaluateExpression(const BoundExpression *expre } } -shared_ptr Evaluator::GetVariable(const BoundVariableExpression* expression){ +const shared_ptr Evaluator::GetVariable(const BoundVariableExpression *expression){ auto variable = this->_evaluationScope->GetVariable(expression->GetKey()); if (variable == nullptr){ throw EvaluationException("Variable not found"); @@ -126,7 +126,7 @@ shared_ptr Evaluator::GetVariable(const BoundVariableExpression* expr return variable->Clone(); } -shared_ptr Evaluator::EvaluateIntegerExpression(const BoundExpression *expression) { +const shared_ptr Evaluator::EvaluateIntegerExpression(const BoundExpression *expression) { switch (expression->GetKind()){ case BoundExpressionKind ::LiteralInteger: return make_shared(((BoundLiteralIntegerExpression*)expression)->GetValue()); case BoundExpressionKind ::LiteralFloat: return make_shared(((BoundLiteralFloatExpression*)expression)->GetValue()); @@ -146,7 +146,7 @@ shared_ptr Evaluator::EvaluateIntegerExpression(const BoundExp } } -shared_ptr Evaluator::EvaluateBoolExpression(const BoundExpression *expression) { +const shared_ptr Evaluator::EvaluateBoolExpression(const BoundExpression *expression) { switch (expression->GetKind()) { case BoundExpressionKind ::LiteralBool: return make_shared(((BoundLiteralBoolExpression*)expression)->GetValue()); case BoundExpressionKind::Unary: return this -> EvaluateBooleanUnary((BoundUnaryExpression*)expression); @@ -167,7 +167,7 @@ shared_ptr Evaluator::EvaluateBoolExpression(const BoundExpres } } -shared_ptr Evaluator::EvaluateStringExpression(const BoundExpression *expression) { +const shared_ptr Evaluator::EvaluateStringExpression(const BoundExpression *expression) { switch (expression->GetKind()) { case BoundExpressionKind ::LiteralString: return make_shared(((BoundLiteralStringExpression*)expression)->GetValue()); @@ -190,7 +190,7 @@ shared_ptr Evaluator::EvaluateStringExpression(const BoundExpre } } -shared_ptr Evaluator::EvaluateFunctionExpression(const BoundExpression * expression){ +const shared_ptr Evaluator::EvaluateFunctionExpression(const BoundExpression *expression){ switch (expression->GetKind()){ case BoundExpressionKind ::Variable: return this->GetVariable((BoundVariableExpression*)expression); case BoundExpressionKind ::Index: return this->EvaluateIndexExpression(expression); @@ -198,7 +198,7 @@ shared_ptr Evaluator::EvaluateFunctionExpression(const BoundExpressio default: throw; } } -shared_ptr Evaluator::EvaluateNilExpression(const BoundExpression * expression){ +const shared_ptr Evaluator::EvaluateNilExpression(const BoundExpression *expression){ switch (expression->GetKind()){ case BoundExpressionKind ::FunctionCall: return this->EvaluateFunctionCallExpression(expression); @@ -206,7 +206,7 @@ shared_ptr Evaluator::EvaluateNilExpression(const BoundExpression * e return nullptr; } } -shared_ptr Evaluator::EvaluateTableExpression(const BoundExpression * expression){ +const shared_ptr Evaluator::EvaluateTableExpression(const BoundExpression *expression){ switch (expression->GetKind()){ case BoundExpressionKind ::FunctionCall: return this->EvaluateFunctionCallExpression(expression); @@ -223,7 +223,7 @@ shared_ptr Evaluator::EvaluateTableExpression(const BoundExpression * -shared_ptr Evaluator::EvaluateFunctionCallExpression(const BoundExpression* expression){ +const shared_ptr Evaluator::EvaluateFunctionCallExpression(const BoundExpression *expression){ auto functionCall = (BoundFunctionCallExpression*)expression; auto function = dynamic_pointer_cast(this->EvaluateExpression(functionCall->GetFunctionExpression())); @@ -253,7 +253,8 @@ shared_ptr Evaluator::EvaluateFunctionCallExpression(const BoundExpre return r; } -shared_ptr Evaluator::EvaluateFunction(const ScriptFunctionEvalValue *function, const vector& parameters) { +const shared_ptr Evaluator::EvaluateFunction(const ScriptFunctionEvalValue *function, + const vector ¶meters) { auto type = std::dynamic_pointer_cast(function->GetType()); auto parameterTypes = type->GetParameterTypes(); auto parameterKeys = type->GetParameterKeys(); @@ -274,21 +275,21 @@ shared_ptr Evaluator::EvaluateFunction(const ScriptFunctionEvalValue return r; } -shared_ptr Evaluator::EvaluateIndexExpression(const BoundExpression *expression) { +const shared_ptr Evaluator::EvaluateIndexExpression(const BoundExpression *expression) { auto indexExpression = (BoundIndexExpression*)expression; auto index = this -> EvaluateExpression(indexExpression->GetIndexExpression()); auto indexable = this -> EvaluateExpression(indexExpression->GetIndexableExpression()); return indexable -> IndexValue(index.get()) -> Clone(); } -shared_ptr Evaluator::EvaluatePeriodIndexExpression(const BoundExpression *expression) { +const shared_ptr Evaluator::EvaluatePeriodIndexExpression(const BoundExpression *expression) { auto indexExpression = (BoundPeriodIndexExpression*)expression; auto index = indexExpression -> GetIndex().GetHash(); auto indexable = this -> EvaluateExpression(indexExpression->GetIndexableExpression()); return indexable -> IndexValue(index) -> Clone(); } -shared_ptr Evaluator::EvaluateNumericTableExpression(const BoundExpression *expression) { +const shared_ptr Evaluator::EvaluateNumericTableExpression(const BoundExpression *expression) { auto tableExpression = (BoundNumericalTableExpression*)expression; auto valueExpressions = tableExpression->GetExpressions(); auto values = new unordered_map>(valueExpressions->size()); @@ -300,7 +301,7 @@ shared_ptr Evaluator::EvaluateNumericTableExpression(const BoundExpre return make_shared(valuesPointer); } -shared_ptr Evaluator::EvaluateComplexTableExpression(const BoundExpression *expression) { +const shared_ptr Evaluator::EvaluateComplexTableExpression(const BoundExpression *expression) { auto tableExpression = (BoundTableExpression*)expression; auto type = dynamic_pointer_cast(tableExpression->GetType()); auto declaredVars = type -> GetValues(); @@ -316,7 +317,7 @@ shared_ptr Evaluator::EvaluateComplexTableExpression(const BoundExpre return make_shared(variables); } -shared_ptr Evaluator::EvaluateUserDataExpression(const BoundExpression *expression) { +const shared_ptr Evaluator::EvaluateUserDataExpression(const BoundExpression *expression) { switch (expression->GetKind()){ case BoundExpressionKind ::Variable: return this->GetVariable((BoundVariableExpression*)expression); case BoundExpressionKind ::Index: return this -> EvaluateIndexExpression(expression); diff --git a/src/Evaluator/Evaluator.hpp b/src/Evaluator/Evaluator.hpp index 2fa5c86..e413a58 100644 --- a/src/Evaluator/Evaluator.hpp +++ b/src/Evaluator/Evaluator.hpp @@ -31,28 +31,28 @@ class Evaluator { void EvaluateReturnStatement(const BoundReturnStatement *statement); void EvaluateConditionalStatement(const BoundConditionalStatement *statement); - shared_ptr EvaluateExpression(const BoundExpression* expression); - shared_ptr EvaluateIntegerExpression(const BoundExpression* expression); - shared_ptr EvaluateBoolExpression(const BoundExpression* expression); - shared_ptr EvaluateStringExpression(const BoundExpression* expression); - shared_ptr EvaluateFunctionExpression(const BoundExpression *expression); - shared_ptrEvaluateNilExpression(const BoundExpression *expression); - shared_ptrEvaluateTableExpression(const BoundExpression *expression); + const shared_ptr EvaluateExpression(const BoundExpression *expression); + const shared_ptr EvaluateIntegerExpression(const BoundExpression *expression); + const shared_ptr EvaluateBoolExpression(const BoundExpression *expression); + const shared_ptr EvaluateStringExpression(const BoundExpression *expression); + const shared_ptr EvaluateFunctionExpression(const BoundExpression *expression); + const shared_ptr EvaluateNilExpression(const BoundExpression *expression); + const shared_ptr EvaluateTableExpression(const BoundExpression *expression); - shared_ptr EvaluateIntegerBinary(const BoundBinaryExpression* expression); - shared_ptr EvaluateBooleanBinary(const BoundBinaryExpression *expression); - shared_ptr EvaluateStringBinary(const BoundBinaryExpression *expression); + const shared_ptr EvaluateIntegerBinary(const BoundBinaryExpression *expression); + const shared_ptr EvaluateBooleanBinary(const BoundBinaryExpression *expression); + const shared_ptr EvaluateStringBinary(const BoundBinaryExpression *expression); - shared_ptr EvaluateIntegerUnary(const BoundUnaryExpression* expression); - shared_ptr EvaluateBooleanUnary(const BoundUnaryExpression *expression); - shared_ptr EvaluateFunctionCallExpression(const BoundExpression *expression); - shared_ptr EvaluateIndexExpression(const BoundExpression* expression); - shared_ptr EvaluatePeriodIndexExpression(const BoundExpression* expression); - shared_ptr EvaluateNumericTableExpression(const BoundExpression* expression); - shared_ptr EvaluateComplexTableExpression(const BoundExpression *expression); - shared_ptr EvaluateUserDataExpression(const BoundExpression *expression); + const shared_ptr EvaluateIntegerUnary(const BoundUnaryExpression *expression); + const shared_ptr EvaluateBooleanUnary(const BoundUnaryExpression *expression); + const shared_ptr EvaluateFunctionCallExpression(const BoundExpression *expression); + const shared_ptr EvaluateIndexExpression(const BoundExpression *expression); + const shared_ptr EvaluatePeriodIndexExpression(const BoundExpression *expression); + const shared_ptr EvaluateNumericTableExpression(const BoundExpression *expression); + const shared_ptr EvaluateComplexTableExpression(const BoundExpression *expression); + const shared_ptr EvaluateUserDataExpression(const BoundExpression *expression); - shared_ptr GetVariable(const BoundVariableExpression *expression); + const shared_ptr GetVariable(const BoundVariableExpression *expression); public: explicit Evaluator(Script* script){ _scriptData = script; @@ -62,7 +62,8 @@ public: } EvalValue* Evaluate(const BoundScriptStatement* statement); - shared_ptr EvaluateFunction(const ScriptFunctionEvalValue *function, const vector& parameters); + const shared_ptr EvaluateFunction(const ScriptFunctionEvalValue *function, + const vector ¶meters); EvalValue* GetLastValue(){ return _lastValue.get(); diff --git a/src/Evaluator/UnaryEvaluation.cpp b/src/Evaluator/UnaryEvaluation.cpp index 2ca7f32..123a475 100644 --- a/src/Evaluator/UnaryEvaluation.cpp +++ b/src/Evaluator/UnaryEvaluation.cpp @@ -4,7 +4,7 @@ #include "EvaluationException.hpp" #include "../Script.hpp" -shared_ptr Evaluator::EvaluateIntegerUnary(const BoundUnaryExpression *expression) { +const shared_ptr Evaluator::EvaluateIntegerUnary(const BoundUnaryExpression *expression) { switch (expression->GetOperation()){ case BoundUnaryOperation::Negation: { @@ -22,7 +22,7 @@ shared_ptr Evaluator::EvaluateIntegerUnary(const BoundUnaryExp } } -shared_ptr Evaluator::EvaluateBooleanUnary(const BoundUnaryExpression *expression) { +const shared_ptr Evaluator::EvaluateBooleanUnary(const BoundUnaryExpression *expression) { switch (expression->GetOperation()){ case BoundUnaryOperation::LogicalNegation: { diff --git a/src/UserData/UserDataValue.hpp b/src/UserData/UserDataValue.hpp index 8b85dfe..e6ef66a 100644 --- a/src/UserData/UserDataValue.hpp +++ b/src/UserData/UserDataValue.hpp @@ -1,5 +1,4 @@ - #ifndef PORYGONLANG_USERDATAVALUE_HPP #define PORYGONLANG_USERDATAVALUE_HPP @@ -9,49 +8,51 @@ #include "UserDataStorage.hpp" class UserDataValue : public EvalValue{ - shared_ptr _userData; + const shared_ptr _userData; void* _obj; public: - UserDataValue(shared_ptr userData, void* obj){ - _userData = std::move(userData); + UserDataValue(shared_ptr userData, void* obj) + : _userData(std::move(userData)) + { _obj = obj; } - UserDataValue(uint32_t userDataId, void* obj){ - _userData = UserDataStorage::GetUserDataType(userDataId); + UserDataValue(uint32_t userDataId, void* obj) + : _userData(UserDataStorage::GetUserDataType(userDataId)) + { _obj = obj; } - const TypeClass GetTypeClass() final{ + const TypeClass GetTypeClass() const final{ return TypeClass ::UserData; } - bool operator ==(EvalValue* b) final { + const bool operator ==(EvalValue* b) const final { if (b->GetTypeClass() != TypeClass::UserData) return false; return _obj == ((UserDataValue*)b)->_obj; } - shared_ptr Clone() final{ + const shared_ptr Clone() const final{ return make_shared(_userData, _obj); } - std::size_t GetHashCode() final{ + const std::size_t GetHashCode() const final{ return reinterpret_cast(_obj); } - shared_ptr IndexValue(EvalValue* val) final { + const shared_ptr IndexValue(EvalValue* val) const final { auto fieldId = val->GetHashCode(); auto field = _userData->GetField(fieldId); return shared_ptr(field->Get(_obj)); } - shared_ptr IndexValue(uint32_t hash) final{ + const shared_ptr IndexValue(uint32_t hash) const final{ auto field = _userData->GetField(hash); return shared_ptr(field->Get(_obj)); } - void SetIndexValue(EvalValue *key, shared_ptr value) final{ + void SetIndexValue(EvalValue *key, const shared_ptr& value) const final{ auto fieldId = key->GetHashCode(); auto field = _userData->GetField(fieldId); field -> Set(_obj, value.get());