Added namespaces to most classes, general cleanup

src/Parser/ParsedExpressions/ParsedExpression.hpp

@@ -11,333 +11,332 @@
 #include "../BinaryOperatorKind.hpp"
 #include "../../Utilities/HashedString.hpp"
 
-enum class ParsedExpressionKind{
-    Bad,
+namespace Porygon::Parser {
+    enum class ParsedExpressionKind {
+        Bad,
 
-    LiteralInteger,
-    LiteralFloat,
-    LiteralString,
-    LiteralBool,
-    Variable,
+        LiteralInteger,
+        LiteralFloat,
+        LiteralString,
+        LiteralBool,
+        Variable,
 
-    Unary,
-    Binary,
-    Parenthesized,
-    FunctionCall,
-    Indexer,
-    PeriodIndexer,
-    NumericalTable,
-    Table,
-};
+        Unary,
+        Binary,
+        Parenthesized,
+        FunctionCall,
+        Indexer,
+        PeriodIndexer,
+        NumericalTable,
+        Table,
+    };
 
-class ParsedExpression {
-    const unsigned int _position;
-    const unsigned int _length;
-public:
-    ParsedExpression(unsigned int position, unsigned int length)
-        : _position(position),
-          _length(length)
-    {
-    }
-
-    virtual ~ParsedExpression() = default;
-
-    virtual const ParsedExpressionKind GetKind() const = 0;
-
-    const unsigned int GetStartPosition() const{
-        return _position;
-    }
-
-    const unsigned int GetEndPosition() const{
-        return _position + _length - 1;
-    }
-
-    const unsigned int GetLength() const{
-        return _length;
-    }
-};
-
-class BadExpression : public ParsedExpression{
-public:
-    BadExpression(unsigned int position, unsigned int length) : ParsedExpression(position, length){}
-
-    const ParsedExpressionKind GetKind() const final {
-        return ParsedExpressionKind::Bad;
-    }
-};
-
-class LiteralIntegerExpression : public ParsedExpression{
-    const long _value;
-public:
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::LiteralInteger;
-    }
-    explicit LiteralIntegerExpression(IntegerToken* token)
-        : ParsedExpression(token -> GetStartPosition(), token -> GetLength()),
-          _value(token -> GetValue())
-    {
-    }
-
-    const long GetValue() const{
-        return _value;
-    }
-};
-
-class LiteralFloatExpression : public ParsedExpression{
-    const double _value;
-public:
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::LiteralFloat;
-    }
-    explicit LiteralFloatExpression(FloatToken* token)
-        : ParsedExpression(token -> GetStartPosition(), token -> GetLength()),
-          _value(token -> GetValue())
-    {
-    }
-
-    const double GetValue() const{
-        return _value;
-    }
-};
-
-class LiteralStringExpression : public ParsedExpression{
-    const u16string _value;
-public:
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::LiteralString;
-    }
-    explicit LiteralStringExpression(StringToken* token)
-        : ParsedExpression(token -> GetStartPosition(), token -> GetLength()),
-          _value(std::move(token -> GetValue()))
-    {
-    }
-
-    const u16string& GetValue() const{
-        return _value;
-    }
-};
-
-class LiteralBoolExpression : public ParsedExpression{
-    const bool _value;
-public:
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::LiteralBool;
-    }
-    explicit LiteralBoolExpression(const IToken* token)
-        : ParsedExpression(token -> GetStartPosition(), token -> GetLength()),
-          _value(token -> GetKind() == TokenKind::TrueKeyword)
-    {
-    }
-
-    const bool GetValue() const{
-        return _value;
-    }
-};
-
-class VariableExpression : public ParsedExpression{
-    const HashedString _value;
-public:
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::Variable;
-    }
-    explicit VariableExpression(IdentifierToken* token) : ParsedExpression(token -> GetStartPosition(), token -> GetLength())
-        , _value(HashedString(token -> GetValue()))
-    {
-    }
-
-    const HashedString GetValue() const{
-        return _value;
-    }
-};
-
-
-class ParenthesizedExpression : public ParsedExpression{
-    const ParsedExpression* _expression;
-public:
-    ~ParenthesizedExpression() override {
-        delete _expression;
-    }
-
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::Parenthesized;
-    }
-
-    explicit ParenthesizedExpression(ParsedExpression* innerExpression, unsigned int start, unsigned int length)
-    : ParsedExpression(start, length), _expression(innerExpression){
-    }
-
-    const ParsedExpression* GetInnerExpression() const{
-        return _expression;
-    }
-};
-
-class UnaryExpression : public ParsedExpression{
-    const UnaryOperatorKind _kind;
-    const ParsedExpression* _operand;
-public:
-    ~UnaryExpression() override {
-        delete _operand;
-    }
-
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::Unary;
-    }
-
-    UnaryExpression(UnaryOperatorKind kind, ParsedExpression* operand, unsigned int start, unsigned int length)
-            : ParsedExpression(start, length),
-              _kind(kind), _operand(operand)
-    {
-    }
-
-    const UnaryOperatorKind GetOperatorKind() const{
-        return _kind;
-    }
-
-    const ParsedExpression* GetOperand() const{
-        return _operand;
-    }
-};
-
-class BinaryExpression : public ParsedExpression{
-    const BinaryOperatorKind _kind;
-    const ParsedExpression* _left;
-    const ParsedExpression* _right;
-public:
-    ~BinaryExpression() override {
-        delete _left;
-        delete _right;
-    }
-
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::Binary;
-    }
-
-    BinaryExpression(BinaryOperatorKind kind, ParsedExpression* left, ParsedExpression* right, unsigned int start,
-                     unsigned int length)
-            : ParsedExpression(start, length),
-            _kind(kind), _left(left), _right(right)
-    {
-    }
-
-    const BinaryOperatorKind GetOperatorKind() const{
-        return _kind;
-    }
-
-    const ParsedExpression* GetLeft() const{
-        return _left;
-    }
-
-    const ParsedExpression* GetRight() const{
-        return _right;
-    }
-};
-
-class FunctionCallExpression : public ParsedExpression{
-    const std::unique_ptr<ParsedExpression> _function;
-    const vector<const ParsedExpression*> _parameters;
-public:
-    FunctionCallExpression(ParsedExpression* function, vector<const ParsedExpression*> parameters, unsigned int start, unsigned int length)
-       : ParsedExpression(start, length),
-       _function(function), _parameters(std::move(parameters))
-   {
-    }
-
-    ~FunctionCallExpression() final{
-        for (auto p : _parameters){
-            delete p;
+    class ParsedExpression {
+        const unsigned int _position;
+        const unsigned int _length;
+    public:
+        ParsedExpression(unsigned int position, unsigned int length)
+                : _position(position),
+                  _length(length) {
         }
-    }
 
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::FunctionCall;
-    }
+        virtual ~ParsedExpression() = default;
 
-    const ParsedExpression* GetFunction() const{
-        return _function.get();
-    }
-    const vector<const ParsedExpression*>* GetParameters() const{
-        return &_parameters;
-    }
-};
+        virtual const ParsedExpressionKind GetKind() const = 0;
 
-class IndexExpression : public ParsedExpression{
-    const ParsedExpression* _indexerExpression;
-    const ParsedExpression* _indexExpression;
-public:
-    IndexExpression(ParsedExpression* indexer, ParsedExpression* index, unsigned int start, unsigned int length)
-        :ParsedExpression(start, length),
-        _indexerExpression(indexer), _indexExpression(index)
-    {
-    }
-
-    ~IndexExpression() final{
-        delete _indexerExpression;
-        delete _indexExpression;
-    }
-
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::Indexer;
-    }
-
-    const ParsedExpression* GetIndexer() const{
-        return _indexerExpression;
-    }
-
-    const ParsedExpression* GetIndex() const{
-        return _indexExpression;
-    }
-};
-
-class PeriodIndexExpression : public ParsedExpression{
-    const ParsedExpression* _indexerExpression;
-    const HashedString _index;
-public:
-    PeriodIndexExpression(ParsedExpression* indexer, HashedString index, unsigned int start, unsigned int length)
-            :ParsedExpression(start, length),
-             _indexerExpression(indexer), _index(index)
-    {
-    }
-
-    ~PeriodIndexExpression() final{
-        delete _indexerExpression;
-    }
-
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::PeriodIndexer;
-    }
-
-    const ParsedExpression* GetIndexer() const{
-        return _indexerExpression;
-    }
-
-    const HashedString& GetIndex() const{
-        return _index;
-    }
-};
-
-
-class ParsedNumericalTableExpression : public ParsedExpression{
-    vector<const ParsedExpression*> _expressions;
-public:
-    ParsedNumericalTableExpression(vector<const ParsedExpression*> expressions, unsigned int start, unsigned int length)
-            : ParsedExpression(start, length){
-        _expressions = std::move(expressions);
-    }
-
-    ~ParsedNumericalTableExpression() final{
-        for (auto s: _expressions){
-            delete s;
+        const unsigned int GetStartPosition() const {
+            return _position;
         }
-    }
 
-    const vector<const ParsedExpression*>* GetExpressions() const{
-        return &_expressions;
-    }
+        const unsigned int GetEndPosition() const {
+            return _position + _length - 1;
+        }
 
-    const ParsedExpressionKind GetKind() const final{
-        return ParsedExpressionKind::NumericalTable;
-    }
-};
+        const unsigned int GetLength() const {
+            return _length;
+        }
+    };
 
+    class BadExpression : public ParsedExpression {
+    public:
+        BadExpression(unsigned int position, unsigned int length) : ParsedExpression(position, length) {}
+
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::Bad;
+        }
+    };
+
+    class LiteralIntegerExpression : public ParsedExpression {
+        const long _value;
+    public:
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::LiteralInteger;
+        }
+
+        explicit LiteralIntegerExpression(IntegerToken *token)
+                : ParsedExpression(token->GetStartPosition(), token->GetLength()),
+                  _value(token->GetValue()) {
+        }
+
+        const long GetValue() const {
+            return _value;
+        }
+    };
+
+    class LiteralFloatExpression : public ParsedExpression {
+        const double _value;
+    public:
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::LiteralFloat;
+        }
+
+        explicit LiteralFloatExpression(FloatToken *token)
+                : ParsedExpression(token->GetStartPosition(), token->GetLength()),
+                  _value(token->GetValue()) {
+        }
+
+        const double GetValue() const {
+            return _value;
+        }
+    };
+
+    class LiteralStringExpression : public ParsedExpression {
+        const u16string _value;
+    public:
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::LiteralString;
+        }
+
+        explicit LiteralStringExpression(StringToken *token)
+                : ParsedExpression(token->GetStartPosition(), token->GetLength()),
+                  _value(std::move(token->GetValue())) {
+        }
+
+        const u16string &GetValue() const {
+            return _value;
+        }
+    };
+
+    class LiteralBoolExpression : public ParsedExpression {
+        const bool _value;
+    public:
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::LiteralBool;
+        }
+
+        explicit LiteralBoolExpression(const IToken *token)
+                : ParsedExpression(token->GetStartPosition(), token->GetLength()),
+                  _value(token->GetKind() == TokenKind::TrueKeyword) {
+        }
+
+        const bool GetValue() const {
+            return _value;
+        }
+    };
+
+    class VariableExpression : public ParsedExpression {
+        const HashedString _value;
+    public:
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::Variable;
+        }
+
+        explicit VariableExpression(IdentifierToken *token) : ParsedExpression(token->GetStartPosition(),
+                                                                               token->GetLength()),
+                                                              _value(HashedString(token->GetValue())) {
+        }
+
+        const HashedString GetValue() const {
+            return _value;
+        }
+    };
+
+
+    class ParenthesizedExpression : public ParsedExpression {
+        const ParsedExpression *_expression;
+    public:
+        ~ParenthesizedExpression() override {
+            delete _expression;
+        }
+
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::Parenthesized;
+        }
+
+        explicit ParenthesizedExpression(ParsedExpression *innerExpression, unsigned int start, unsigned int length)
+                : ParsedExpression(start, length), _expression(innerExpression) {
+        }
+
+        const ParsedExpression *GetInnerExpression() const {
+            return _expression;
+        }
+    };
+
+    class UnaryExpression : public ParsedExpression {
+        const UnaryOperatorKind _kind;
+        const ParsedExpression *_operand;
+    public:
+        ~UnaryExpression() override {
+            delete _operand;
+        }
+
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::Unary;
+        }
+
+        UnaryExpression(UnaryOperatorKind kind, ParsedExpression *operand, unsigned int start, unsigned int length)
+                : ParsedExpression(start, length),
+                  _kind(kind), _operand(operand) {
+        }
+
+        const UnaryOperatorKind GetOperatorKind() const {
+            return _kind;
+        }
+
+        const ParsedExpression *GetOperand() const {
+            return _operand;
+        }
+    };
+
+    class BinaryExpression : public ParsedExpression {
+        const BinaryOperatorKind _kind;
+        const ParsedExpression *_left;
+        const ParsedExpression *_right;
+    public:
+        ~BinaryExpression() override {
+            delete _left;
+            delete _right;
+        }
+
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::Binary;
+        }
+
+        BinaryExpression(BinaryOperatorKind kind, ParsedExpression *left, ParsedExpression *right, unsigned int start,
+                         unsigned int length)
+                : ParsedExpression(start, length),
+                  _kind(kind), _left(left), _right(right) {
+        }
+
+        const BinaryOperatorKind GetOperatorKind() const {
+            return _kind;
+        }
+
+        const ParsedExpression *GetLeft() const {
+            return _left;
+        }
+
+        const ParsedExpression *GetRight() const {
+            return _right;
+        }
+    };
+
+    class FunctionCallExpression : public ParsedExpression {
+        const std::unique_ptr<ParsedExpression> _function;
+        const vector<const ParsedExpression *> _parameters;
+    public:
+        FunctionCallExpression(ParsedExpression *function, vector<const ParsedExpression *> parameters,
+                               unsigned int start, unsigned int length)
+                : ParsedExpression(start, length),
+                  _function(function), _parameters(std::move(parameters)) {
+        }
+
+        ~FunctionCallExpression() final {
+            for (auto p : _parameters) {
+                delete p;
+            }
+        }
+
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::FunctionCall;
+        }
+
+        const ParsedExpression *GetFunction() const {
+            return _function.get();
+        }
+
+        const vector<const ParsedExpression *> *GetParameters() const {
+            return &_parameters;
+        }
+    };
+
+    class IndexExpression : public ParsedExpression {
+        const ParsedExpression *_indexerExpression;
+        const ParsedExpression *_indexExpression;
+    public:
+        IndexExpression(ParsedExpression *indexer, ParsedExpression *index, unsigned int start, unsigned int length)
+                : ParsedExpression(start, length),
+                  _indexerExpression(indexer), _indexExpression(index) {
+        }
+
+        ~IndexExpression() final {
+            delete _indexerExpression;
+            delete _indexExpression;
+        }
+
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::Indexer;
+        }
+
+        const ParsedExpression *GetIndexer() const {
+            return _indexerExpression;
+        }
+
+        const ParsedExpression *GetIndex() const {
+            return _indexExpression;
+        }
+    };
+
+    class PeriodIndexExpression : public ParsedExpression {
+        const ParsedExpression *_indexerExpression;
+        const HashedString _index;
+    public:
+        PeriodIndexExpression(ParsedExpression *indexer, HashedString index, unsigned int start, unsigned int length)
+                : ParsedExpression(start, length),
+                  _indexerExpression(indexer), _index(index) {
+        }
+
+        ~PeriodIndexExpression() final {
+            delete _indexerExpression;
+        }
+
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::PeriodIndexer;
+        }
+
+        const ParsedExpression *GetIndexer() const {
+            return _indexerExpression;
+        }
+
+        const HashedString &GetIndex() const {
+            return _index;
+        }
+    };
+
+
+    class ParsedNumericalTableExpression : public ParsedExpression {
+        vector<const ParsedExpression *> _expressions;
+    public:
+        ParsedNumericalTableExpression(vector<const ParsedExpression *> expressions, unsigned int start,
+                                       unsigned int length)
+                : ParsedExpression(start, length) {
+            _expressions = std::move(expressions);
+        }
+
+        ~ParsedNumericalTableExpression() final {
+            for (auto s: _expressions) {
+                delete s;
+            }
+        }
+
+        const vector<const ParsedExpression *> *GetExpressions() const {
+            return &_expressions;
+        }
+
+        const ParsedExpressionKind GetKind() const final {
+            return ParsedExpressionKind::NumericalTable;
+        }
+    };
+}
 
 #endif //PORYGONLANG_PARSEDEXPRESSION_HPP