Implements setting table values

src/Parser/ParsedStatements/ParsedStatement.hpp

@@ -19,6 +19,7 @@ enum class ParsedStatementKind{
     Block,
     Expression,
     Assignment,
+    IndexAssignment,
     FunctionDeclaration,
     Return,
     Conditional
@@ -180,6 +181,33 @@ public:
     }
 };
 
+class ParsedIndexAssignmentStatement : public ParsedStatement{
+    const ParsedExpression* _indexExpression;
+    const ParsedExpression* _valueExpression;
+public:
+    ParsedIndexAssignmentStatement(ParsedExpression* indexExpression, ParsedExpression* valueExpression, unsigned int start,
+                                   unsigned int length)
+                                   : ParsedStatement(start, length),
+                                   _indexExpression(indexExpression), _valueExpression(valueExpression){}
+
+    ~ParsedIndexAssignmentStatement() final{
+        delete _indexExpression;
+        delete _valueExpression;
+    }
+
+    const ParsedStatementKind GetKind() const final{
+        return ParsedStatementKind ::IndexAssignment;
+    }
+
+    const ParsedExpression* GetIndexExpression() const{
+        return _indexExpression;
+    }
+
+    const ParsedExpression* GetValueExpression() const{
+        return _valueExpression;
+    }
+};
+
 class ParsedReturnStatement : public ParsedStatement{
     const ParsedExpression* _expression;
 public:

src/Parser/Parser.cpp

@@ -1,6 +1,4 @@
 #include <utility>
-
-
 #include <algorithm>
 #include "Parser.hpp"
 #include "ParsedStatements/ParsedStatement.hpp"
@@ -38,19 +36,23 @@ const IToken *Parser::Next() {
 ParsedStatement* Parser::ParseStatement(const IToken* current){
     auto currentKind = current->GetKind();
     switch (currentKind){
-        case TokenKind ::LocalKeyword: return this -> ParseAssignment(current);
+        case TokenKind ::LocalKeyword: return this->ParseVariableAssignment(current);
         case TokenKind ::FunctionKeyword: return this -> ParseFunctionDeclaration(current);
         case TokenKind ::ReturnKeyword: return this->ParseReturnStatement(current);
         case TokenKind ::IfKeyword: return this -> ParseIfStatement(current);
         default: break;
     }
     if (this->Peek()->GetKind() == TokenKind::AssignmentToken){
-        return ParseAssignment(current);
+        return ParseVariableAssignment(current);
     }
-    return new ParsedExpressionStatement(this -> ParseExpression(current));
+    auto expression = this -> ParseExpression(current);
+    if (expression->GetKind() == ParsedExpressionKind::Indexer && this -> Peek()->GetKind() == TokenKind::AssignmentToken){
+        return this -> ParseIndexAssignment(expression);
+    }
+    return new ParsedExpressionStatement(expression);
 }
 
-ParsedStatement *Parser::ParseAssignment(const IToken *current) {
+ParsedStatement *Parser::ParseVariableAssignment(const IToken *current) {
     bool isLocal = false;
     const IToken* identifier;
     if (current -> GetKind() == TokenKind::LocalKeyword){
@@ -75,6 +77,14 @@ ParsedStatement *Parser::ParseAssignment(const IToken *current) {
     return new ParsedAssignmentStatement(isLocal, ((IdentifierToken*)identifier) -> GetValue(), expression, start, expression->GetEndPosition() - start);
 }
 
+ParsedStatement *Parser::ParseIndexAssignment(ParsedExpression *indexer) {
+    this -> Next(); // Consume assignment token
+    auto valueExpression = this -> ParseExpression(this -> Next());
+    auto start = indexer->GetStartPosition();
+    return new ParsedIndexAssignmentStatement(indexer, valueExpression, start, valueExpression->GetEndPosition() - start);
+}
+
+
 ParsedStatement *Parser::ParseBlock(const vector<TokenKind>& endTokens, const vector<const ParsedStatement*>& openStatements) {
     auto statements = openStatements;
     auto start = this->_position;

src/Parser/Parser.hpp

@@ -27,7 +27,8 @@ class Parser {
     const IToken* Next();
 
     ParsedStatement* ParseStatement(const IToken* current);
-    ParsedStatement* ParseAssignment(const IToken* current);
+    ParsedStatement* ParseVariableAssignment(const IToken *current);
+    ParsedStatement* ParseIndexAssignment(ParsedExpression *indexer);
     ParsedStatement *ParseBlock(const vector<TokenKind>& endTokens, const vector<const ParsedStatement*>& openStatements = {});
     ParsedStatement* ParseFunctionDeclaration(const IToken* current);
     ParsedStatement *ParseReturnStatement(const IToken *current);