PorygonLang/src/Binder/BoundExpressions/BoundExpression.hpp

#ifndef PORYGONLANG_BOUNDEXPRESSION_HPP
#define PORYGONLANG_BOUNDEXPRESSION_HPP

#include <string>
#include <memory>
#include <utility>
#include "../../ScriptType.hpp"
#include "../BoundOperators.hpp"
#include "../BoundVariables/BoundVariableKey.hpp"
#include "../../FunctionScriptType.hpp"

using namespace std;

namespace Porygon::Binder {
    enum class BoundExpressionKind {
        Bad,

        LiteralInteger,
        LiteralFloat,
        LiteralString,
        LiteralBool,
        Variable,

        Unary,
        Binary,
        FunctionCall,
        Index,
        PeriodIndex,
        NumericalTable,
        Table,
    };

    class BoundExpression {
        const unsigned int _start;
        const unsigned int _length;
        const shared_ptr<ScriptType> _type;
    public:
        BoundExpression(unsigned int start, unsigned int length, shared_ptr<ScriptType> type)
                : _start(start),
                  _length(length),
                  _type(std::move(type)) {
        }

        virtual ~BoundExpression() = default;

        virtual const BoundExpressionKind GetKind() const = 0;

        virtual const std::shared_ptr<ScriptType> &GetType() const {
            return _type;
        };

        const unsigned int GetStartPosition() const {
            return _start;
        }

        const unsigned int GetLength() const {
            return _length;
        }

        const unsigned int GetEndPosition() const {
            return _start + _length - 1;
        }
    };

    class BoundBadExpression : public BoundExpression {
    public:
        BoundBadExpression(unsigned int start, unsigned int length) : BoundExpression(start, length,
                                                                                      make_shared<ScriptType>(
                                                                                              TypeClass::Error)) {}

        const BoundExpressionKind GetKind() const final {
            return BoundExpressionKind::Bad;
        }
    };

    class BoundLiteralIntegerExpression : public BoundExpression {
        const long _value;
    public:
        BoundLiteralIntegerExpression(long value, unsigned int start, unsigned int length)
                : BoundExpression(start, length, make_shared<NumericScriptType>(true, false)),
                  _value(value) {
        }

        const BoundExpressionKind GetKind() const final {
            return BoundExpressionKind::LiteralInteger;
        }

        const long GetValue() const {
            return _value;
        }
    };

    class BoundLiteralFloatExpression : public BoundExpression {
        const double _value;
    public:
        BoundLiteralFloatExpression(double value, unsigned int start, unsigned int length)
                : BoundExpression(start, length, make_shared<NumericScriptType>(true, true)),
                  _value(value) {
        }

        const BoundExpressionKind GetKind() const final {
            return BoundExpressionKind::LiteralFloat;
        }

        const double GetValue() const {
            return _value;
        }
    };

    class BoundLiteralStringExpression : public BoundExpression {
        const u16string _value;
    public:
        BoundLiteralStringExpression(const u16string &value, unsigned int start, unsigned int length)
                : BoundExpression(start, length,
                                  make_shared<StringScriptType>(true, Utilities::HashedString::ConstHash(value.c_str()))),
                  _value(value) {
        }

        const BoundExpressionKind GetKind() const final {
            return BoundExpressionKind::LiteralString;
        }

        const u16string GetValue() const {
            return _value;
        }
    };

    class BoundLiteralBoolExpression : public BoundExpression {
        const bool _value;
    public:
        BoundLiteralBoolExpression(bool value, unsigned int start, unsigned int length)
                : BoundExpression(start, length, make_shared<ScriptType>(TypeClass::Bool)),
                  _value(value) {
        }

        const BoundExpressionKind GetKind() const final {
            return BoundExpressionKind::LiteralBool;
        }

        const bool GetValue() const {
            return _value;
        }
    };

    class BoundVariableExpression : public BoundExpression {
        const BoundVariableKey *_key;
    public:
        BoundVariableExpression(BoundVariableKey *key, shared_ptr<ScriptType> type, unsigned int start,
                                unsigned int length)
                : BoundExpression(start, length, std::move(type)),
                  _key(key) {
        }

        ~BoundVariableExpression() override {
            delete _key;
        }

        const BoundExpressionKind GetKind() const final {
            return BoundExpressionKind::Variable;
        }

        const BoundVariableKey *GetKey() const {
            return _key;
        }
    };

    class BoundBinaryExpression : public BoundExpression {
        const BoundExpression *_left;
        const BoundExpression *_right;
        const BoundBinaryOperation _operation;
    public:
        BoundBinaryExpression(BoundExpression *left, BoundExpression *right, BoundBinaryOperation op,
                              shared_ptr<ScriptType> result,
                              unsigned int start, unsigned int length)
                : BoundExpression(start, length, std::move(result)),
                  _left(left),
                  _right(right),
                  _operation(op) {
        }

        ~BoundBinaryExpression() final {
            delete _left;
            delete _right;
        }

        const BoundExpressionKind GetKind() const final {
            return BoundExpressionKind::Binary;
        }

        const BoundExpression *GetLeft() const {
            return _left;
        }

        const BoundExpression *GetRight() const {
            return _right;
        }

        const BoundBinaryOperation GetOperation() const {
            return _operation;
        }
    };

    class BoundUnaryExpression : public BoundExpression {
        const BoundExpression *_operand;
        const BoundUnaryOperation _operation;
    public:
        BoundUnaryExpression(BoundExpression *operand, BoundUnaryOperation op, shared_ptr<ScriptType> result,
                             unsigned int start, unsigned int length)
                : BoundExpression(start, length, std::move(result)),
                  _operand(operand),
                  _operation(op) {
        }

        ~BoundUnaryExpression() final {
            delete _operand;
        }

        const BoundExpressionKind GetKind() const final {
            return BoundExpressionKind::Unary;
        }

        const BoundExpression *GetOperand() const {
            return _operand;
        }

        const BoundUnaryOperation GetOperation() const {
            return _operation;
        }
    };

    class BoundIndexExpression : public BoundExpression {
        const BoundExpression *_indexableExpression;
        const BoundExpression *_indexExpression;
    public:
        BoundIndexExpression(BoundExpression *indexableExpression, BoundExpression *indexExpression,
                             shared_ptr<ScriptType> result,
                             unsigned int start, unsigned int length)
                : BoundExpression(start, length, std::move(result)), _indexableExpression(indexableExpression),
                  _indexExpression(indexExpression) {}

        ~BoundIndexExpression() final {
            delete _indexableExpression;
            delete _indexExpression;
        }

        const BoundExpressionKind GetKind() const final {
            return BoundExpressionKind::Index;
        }

        const BoundExpression *GetIndexableExpression() const {
            return _indexableExpression;
        }

        const BoundExpression *GetIndexExpression() const {
            return _indexExpression;
        }
    };

    class BoundPeriodIndexExpression : public BoundExpression {
        const BoundExpression *_indexableExpression;
        const Utilities::HashedString _index;
    public:
        BoundPeriodIndexExpression(BoundExpression *indexableExpression, Utilities::HashedString index,
                                   shared_ptr<ScriptType> result,
                                   unsigned int start, unsigned int length)
                : BoundExpression(start, length, std::move(result)), _indexableExpression(indexableExpression),
                  _index(index) {}

        ~BoundPeriodIndexExpression() final {
            delete _indexableExpression;
        }

        const BoundExpressionKind GetKind() const final {
            return BoundExpressionKind::PeriodIndex;
        }

        const BoundExpression *GetIndexableExpression() const {
            return _indexableExpression;
        }

        const Utilities::HashedString GetIndex() const {
            return _index;
        }
    };

    class BoundNumericalTableExpression : public BoundExpression {
        const vector<const BoundExpression *> _expressions;
    public:
        BoundNumericalTableExpression(vector<const BoundExpression *> expressions, shared_ptr<ScriptType> type,
                                      unsigned int start, unsigned int length)
                : BoundExpression(start, length, std::move(type)),
                  _expressions(std::move(expressions)) {}

        ~BoundNumericalTableExpression() final {
            for (auto e: _expressions) {
                delete e;
            }
        }

        const BoundExpressionKind GetKind() const final {
            return BoundExpressionKind::NumericalTable;
        }

        const vector<const BoundExpression *> *GetExpressions() const {
            return &_expressions;
        }
    };
}

#endif //PORYGONLANG_BOUNDEXPRESSION_HPP