PorygonLang/src/Parser/ParsedStatements/ParsedStatement.hpp

#ifndef PORYGONLANG_PARSEDSTATEMENT_HPP
#define PORYGONLANG_PARSEDSTATEMENT_HPP

#include <utility>
#include <vector>
#include <string>

#include "../ParsedExpressions/ParsedExpression.hpp"
#include "../../Utilities/HashedString.hpp"
#include "../TypedVariableIdentifier.hpp"

enum class ParsedStatementKind{
    Bad,
    Script,
    Block,
    Expression,
    Assignment,
    FunctionDeclaration,
    Return,
    Conditional
};

class ParsedStatement {
    unsigned int _start;
    unsigned int _length;
public:
    ParsedStatement(unsigned int start, unsigned int length){
        _start = start;
        _length = length;
    }
    virtual ~ParsedStatement() = default;
    virtual ParsedStatementKind  GetKind() = 0;

    unsigned int GetStartPosition(){
        return _start;
    }

    unsigned int GetLength(){
        return _length;
    }

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

class ParsedBadStatement : public ParsedStatement{
public:
    ParsedBadStatement(unsigned int start, unsigned int length) : ParsedStatement(start, length){};
    ParsedStatementKind GetKind() final{
        return ParsedStatementKind ::Bad;
    }
};

class ParsedBlockStatement : public ParsedStatement{
    std::vector<ParsedStatement*> _statements;
public:
    explicit ParsedBlockStatement(std::vector<ParsedStatement*> statements)
        : ParsedStatement(statements.front()->GetStartPosition(), statements.back()->GetEndPosition() - statements.front()->GetStartPosition()){
        _statements = std::move(statements);
    }
    ~ParsedBlockStatement() override {
        for (auto s: _statements){
            delete s;
        }
        _statements.clear();
    }

    ParsedStatementKind GetKind() override{
        return ParsedStatementKind ::Block;
    }

    std::vector<ParsedStatement*> GetStatements(){
        return _statements;
    }
};

class ParsedScriptStatement : public ParsedBlockStatement{
public:
    explicit ParsedScriptStatement(vector<ParsedStatement*> statements) : ParsedBlockStatement(move(statements)){}

    ParsedStatementKind GetKind() final{
        return ParsedStatementKind ::Script;
    }
};

class ParsedExpressionStatement : public ParsedStatement{
    ParsedExpression* _expression;
public:
    explicit ParsedExpressionStatement(ParsedExpression* expression) : ParsedStatement(expression->GetStartPosition(), expression->GetLength()){
        _expression = expression;
    }
    ~ParsedExpressionStatement() override {
        delete _expression;
    }

    ParsedStatementKind GetKind() final{
        return ParsedStatementKind ::Expression;
    }

    ParsedExpression* GetExpression(){
        return _expression;
    }
};

class ParsedFunctionDeclarationStatement : public ParsedStatement{
    HashedString _identifier;
    vector<TypedVariableIdentifier*> _parameters;
    ParsedBlockStatement* _block;
public:
    ParsedFunctionDeclarationStatement(HashedString identifier, vector<TypedVariableIdentifier*> parameters, ParsedBlockStatement* block,
                                       unsigned int start, unsigned int length)
        : ParsedStatement(start, length), _identifier(identifier), _parameters(std::move(parameters)), _block(block){};

    ~ParsedFunctionDeclarationStatement() override {
        for (auto v : _parameters){
            delete v;
        }
        delete _block;
    }

    ParsedStatementKind GetKind() final{
        return ParsedStatementKind ::FunctionDeclaration;
    }

    HashedString GetIdentifier(){
        return _identifier;
    }

    vector<TypedVariableIdentifier*> GetParameters(){
        return _parameters;
    }

    ParsedBlockStatement* GetBlock(){
        return _block;
    }
};

class ParsedAssignmentStatement : public ParsedStatement{
    bool _local;
    HashedString _identifier;
    ParsedExpression* _expression;
public:
    ParsedAssignmentStatement(bool local, std::string identifier, ParsedExpression* expression, unsigned int start, unsigned int length)
    : ParsedStatement(start, length), _identifier(HashedString(std::move(identifier)))
    {
        _local = local;
        _expression = expression;
    }
    ~ParsedAssignmentStatement() final{
        delete _expression;
    }

    ParsedStatementKind GetKind() final{
        return ParsedStatementKind ::Assignment;
    }

    bool IsLocal(){
        return _local;
    }

    HashedString GetIdentifier(){
        return _identifier;
    }

    ParsedExpression* GetExpression(){
        return _expression;
    }
};

class ParsedReturnStatement : public ParsedStatement{
    ParsedExpression* _expression;
public:
    ParsedReturnStatement(ParsedExpression* expression, unsigned int start, unsigned int length) : ParsedStatement(start, length){
        _expression = expression;
    }

    ~ParsedReturnStatement() final{
        delete _expression;
    }

    ParsedStatementKind GetKind() final{
        return ParsedStatementKind ::Return;
    }

    ParsedExpression* GetExpression(){
        return _expression;
    }
};

class ParsedConditionalStatement : public ParsedStatement{
    ParsedExpression* _condition;
    ParsedStatement* _block;
    // This can be either else if or else
    ParsedStatement* _elseStatement;
public:
    ParsedConditionalStatement(ParsedExpression* condition, ParsedStatement* block, unsigned int start, unsigned int length)
    : ParsedStatement(start, length){
        _condition = condition;
        _block = block;
        _elseStatement = nullptr;
    }

    ParsedConditionalStatement(ParsedExpression* condition, ParsedStatement* block, ParsedStatement* nextStatement, unsigned int start, unsigned int length)
            : ParsedStatement(start, length){
        _condition = condition;
        _block = block;
        _elseStatement = nextStatement;
    }

    ~ParsedConditionalStatement() final{
        delete _condition;
        delete _block;
        delete _elseStatement;
    }

    ParsedStatementKind GetKind() final{
        return ParsedStatementKind ::Conditional;
    }

    ParsedExpression* GetCondition(){
        return _condition;
    }

    ParsedStatement* GetBlock(){
        return _block;
    }

    ParsedStatement* GetElseStatement(){
        return _elseStatement;
    }
};

#endif //PORYGONLANG_PARSEDSTATEMENT_HPP