From 49effd8723c8ce44696f90208225c3296a8ad512 Mon Sep 17 00:00:00 2001 From: marcelnoehre Date: Wed, 5 Feb 2025 12:44:34 +0100 Subject: [PATCH 1/9] fixes for new parser version --- .../short_operation_expression.hpp | 7 +++-- include/interpreter/storage.hpp | 4 +-- .../expressions/binary_expression.cpp | 4 +-- src/interpreter/expressions/expression.cpp | 4 +-- .../short_operation_expression.cpp | 15 ++++++++++ src/interpreter/statements/log_statement.cpp | 4 ++- src/interpreter/storage.cpp | 28 ++----------------- 7 files changed, 31 insertions(+), 35 deletions(-) diff --git a/include/interpreter/expressions/short_operation_expression.hpp b/include/interpreter/expressions/short_operation_expression.hpp index e3c5098..20e412d 100644 --- a/include/interpreter/expressions/short_operation_expression.hpp +++ b/include/interpreter/expressions/short_operation_expression.hpp @@ -10,12 +10,13 @@ class ShortOperationExpression { public: - ShortOperationExpression(ShortOperationLiteral *expressionNode, - std::vector> storage); + ShortOperationExpression(ShortOperationExpr *expressionNode, + std::vector> storage); Storage::DataWrapper execute(); + Storage::DataWrapper executeExpression(Storage::DataWrapper leftValue); private: - ShortOperationLiteral *expressionNode; + ShortOperationExpr *expressionNode; std::vector> storage; }; diff --git a/include/interpreter/storage.hpp b/include/interpreter/storage.hpp index ea4e6e3..fe23d05 100644 --- a/include/interpreter/storage.hpp +++ b/include/interpreter/storage.hpp @@ -39,7 +39,7 @@ class Storage { std::map *_object; FunctionDeclaration *_function; CallbackFunctionExpr *_callbackFunction; - ShortOperationLiteral *_shortOperation; + ShortOperationExpr *_shortOperation; Data(); Data(int value); @@ -51,7 +51,7 @@ class Storage { Data(std::map *value); Data(FunctionDeclaration *value); Data(CallbackFunctionExpr *value); - Data(ShortOperationLiteral *value); + Data(ShortOperationExpr *value); ~Data(); }; diff --git a/src/interpreter/expressions/binary_expression.cpp b/src/interpreter/expressions/binary_expression.cpp index 240d7ae..026b68d 100644 --- a/src/interpreter/expressions/binary_expression.cpp +++ b/src/interpreter/expressions/binary_expression.cpp @@ -379,7 +379,7 @@ Storage::DataWrapper BinaryExpression::stringAddition(std::string left, std::string right) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::STRING, - new std::string(left + right)); + static_cast(new std::string(left + right))); } Storage::DataWrapper BinaryExpression::stringMultiplication(std::string value, @@ -390,5 +390,5 @@ Storage::DataWrapper BinaryExpression::stringMultiplication(std::string value, } return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::STRING, - new std::string(result)); + static_cast(new std::string(result))); } diff --git a/src/interpreter/expressions/expression.cpp b/src/interpreter/expressions/expression.cpp index f06ab60..0dbd30f 100644 --- a/src/interpreter/expressions/expression.cpp +++ b/src/interpreter/expressions/expression.cpp @@ -30,9 +30,9 @@ Storage::DataWrapper Expression::execute() { return CallbackFunctionExpression( dynamic_cast(exprNode), storage) .execute(); - case NodeType::ShortOperationLiteral: + case NodeType::ShortOperationExpr: return ShortOperationExpression( - dynamic_cast(exprNode), storage) + dynamic_cast(exprNode), storage) .execute(); default: return LiteralExpression(exprNode, storage).execute(); diff --git a/src/interpreter/expressions/short_operation_expression.cpp b/src/interpreter/expressions/short_operation_expression.cpp index b99cd42..3c5c86c 100644 --- a/src/interpreter/expressions/short_operation_expression.cpp +++ b/src/interpreter/expressions/short_operation_expression.cpp @@ -6,4 +6,19 @@ ShortOperationExpression::ShortOperationExpression(ShortOperationLiteral *expres Storage::DataWrapper ShortOperationExpression::execute() { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::SHORT_NOTATION_OPERATION, expressionNode); +} + +Storage::DataWrapper ShortOperationExpression::executeExpression(Storage::DataWrapper leftValue) { + Storage::DataWrapper rightValue = Expression(expressionNode->operand.get(), storage).execute(); + + switch (expressionNode->operation.tag) { + case Token::TypeTag::LOGICAL: + break; + case Token::TypeTag::OPERATOR: + break; + case Token::TypeTag::SHORT_NOTATION: + break; + default: + throw std::invalid_argument("Invalid short operation: " + expressionNode->operation.value); + } } \ No newline at end of file diff --git a/src/interpreter/statements/log_statement.cpp b/src/interpreter/statements/log_statement.cpp index b5527b9..26e6caa 100644 --- a/src/interpreter/statements/log_statement.cpp +++ b/src/interpreter/statements/log_statement.cpp @@ -17,7 +17,9 @@ void LogStatement::execute() { if (i > 0) { printableValue += ", "; } - printableValue += getPrintableValue(Expression(dynamic_cast(logNode->message[i].get()), storage).execute()); + printableValue += getPrintableValue( + Expression(dynamic_cast(logNode->message[i].get()), storage) + .execute()); } switch (logNode->logType.type.logToken) { diff --git a/src/interpreter/storage.cpp b/src/interpreter/storage.cpp index 67cf4f3..b5d1f39 100644 --- a/src/interpreter/storage.cpp +++ b/src/interpreter/storage.cpp @@ -11,7 +11,7 @@ Storage::Data::Data(std::map *value) : _object(value) {} Storage::Data::Data(FunctionDeclaration *value) : _function(value) {} Storage::Data::Data(CallbackFunctionExpr *value) : _callbackFunction(value) {} -Storage::Data::Data(ShortOperationLiteral *value) : _shortOperation(value) {} +Storage::Data::Data(ShortOperationExpr *value) : _shortOperation(value) {} Storage::Data::~Data() {} Storage::DataWrapper::DataWrapper() @@ -26,7 +26,8 @@ Storage::DataWrapper::DataWrapper(WrapperType st, DataType dt, data._function = value._function; } else if (dt == DataType::CALLBACK_FUNCTION && value._callbackFunction) { data._callbackFunction = value._callbackFunction; - } else if (dt == DataType::SHORT_NOTATION_OPERATION && value._shortOperation) { + } else if (dt == DataType::SHORT_NOTATION_OPERATION && + value._shortOperation) { data._shortOperation = value._shortOperation; } else { data = value; @@ -64,14 +65,6 @@ Storage::DataWrapper::operator=(const DataWrapper &other) { dataType = other.dataType; if (dataType == DataType::STRING || dataType == DataType::HEXCODE) { data._string = new std::string(*other.data._string); - } else if (dataType == DataType::FUNCTION && other.data._function) { - data._function = other.data._function; - } else if (dataType == DataType::CALLBACK_FUNCTION && - other.data._callbackFunction) { - data._callbackFunction = other.data._callbackFunction; - } else if (dataType == DataType::SHORT_NOTATION_OPERATION && - other.data._shortOperation) { - data._shortOperation = other.data._shortOperation; } else { data = other.data; } @@ -97,21 +90,6 @@ void Storage::DataWrapper::clear() { if (dataType == DataType::STRING || dataType == DataType::HEXCODE) { delete data._string; data._string = nullptr; - } else if (dataType == DataType::ARRAY) { - delete data._array; - data._array = nullptr; - } else if (dataType == DataType::OBJECT) { - delete data._object; - data._object = nullptr; - } else if (dataType == DataType::FUNCTION) { - delete data._function; - data._function = nullptr; - } else if (dataType == DataType::CALLBACK_FUNCTION) { - delete data._callbackFunction; - data._callbackFunction = nullptr; - } else if (dataType == DataType::SHORT_NOTATION_OPERATION) { - delete data._shortOperation; - data._shortOperation = nullptr; } } From 873ffd9e173c10a796f379124ce94dc59eb7af10 Mon Sep 17 00:00:00 2001 From: marcelnoehre Date: Wed, 5 Feb 2025 12:44:44 +0100 Subject: [PATCH 2/9] handle short operations --- .../short_operation_expression.cpp | 91 ++++++++++++++++--- 1 file changed, 76 insertions(+), 15 deletions(-) diff --git a/src/interpreter/expressions/short_operation_expression.cpp b/src/interpreter/expressions/short_operation_expression.cpp index 3c5c86c..d2cdd6e 100644 --- a/src/interpreter/expressions/short_operation_expression.cpp +++ b/src/interpreter/expressions/short_operation_expression.cpp @@ -1,24 +1,85 @@ #include "interpreter/expressions/short_operation_expression.hpp" -ShortOperationExpression::ShortOperationExpression(ShortOperationLiteral *expressionNode, - std::vector> storage) +ShortOperationExpression::ShortOperationExpression( + ShortOperationExpr *expressionNode, + std::vector> storage) : expressionNode(expressionNode), storage(std::move(storage)) {} Storage::DataWrapper ShortOperationExpression::execute() { - return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::SHORT_NOTATION_OPERATION, expressionNode); + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::SHORT_NOTATION_OPERATION, + expressionNode); } -Storage::DataWrapper ShortOperationExpression::executeExpression(Storage::DataWrapper leftValue) { - Storage::DataWrapper rightValue = Expression(expressionNode->operand.get(), storage).execute(); - - switch (expressionNode->operation.tag) { - case Token::TypeTag::LOGICAL: - break; - case Token::TypeTag::OPERATOR: - break; - case Token::TypeTag::SHORT_NOTATION: - break; - default: - throw std::invalid_argument("Invalid short operation: " + expressionNode->operation.value); +Storage::DataWrapper +ShortOperationExpression::executeExpression(Storage::DataWrapper leftValue) { + Storage::DataWrapper rightValue = + Expression(expressionNode->operand.get(), storage).execute(); + switch (expressionNode->operation.tag) { + case Token::TypeTag::LOGICAL: + if (expressionNode->operation.type.logicalToken == LogicalToken::GREATER) { + return Storage::DataWrapper( + Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, + checkGreater(leftValue, rightValue)); + } else if (expressionNode->operation.type.logicalToken == + LogicalToken::LESS) { + return Storage::DataWrapper( + Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, + checkGreater(rightValue, leftValue)); + } else if (expressionNode->operation.type.logicalToken == + LogicalToken::GREATER_EQUAL) { + return Storage::DataWrapper( + Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, + checkGreater(leftValue, rightValue) || checkEquality(leftValue, rightValue, true)); + } else if (expressionNode->operation.type.logicalToken == + LogicalToken::LESS_EQUAL) { + return Storage::DataWrapper( + Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, + checkGreater(rightValue, leftValue) || checkEquality(leftValue, rightValue, true)); + } else if (expressionNode->operation.type.logicalToken == + LogicalToken::EQUAL) { + return Storage::DataWrapper( + Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, + checkEquality(leftValue, rightValue, true)); + } else if (expressionNode->operation.type.logicalToken == + LogicalToken::NOT_EQUAL) { + return Storage::DataWrapper( + Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, + checkEquality(leftValue, rightValue, false)); + } else { + throw std::invalid_argument("Invalid logical operation: " + + expressionNode->operation.value); + } + break; + case Token::TypeTag::OPERATOR: + if (expressionNode->operation.type.operatorToken == + OperatorToken::ADDITION) { + return BinaryExpression::addition(leftValue, rightValue); + } else if (expressionNode->operation.type.operatorToken == + OperatorToken::SUBTRACTION) { + return BinaryExpression::subtraction(leftValue, rightValue); + } else if (expressionNode->operation.type.operatorToken == + OperatorToken::MULTIPLICATION) { + return BinaryExpression::multiplication(leftValue, rightValue); + } else if (expressionNode->operation.type.operatorToken == + OperatorToken::DIVISION) { + return BinaryExpression::division(leftValue, rightValue); + } else if (expressionNode->operation.type.operatorToken == + OperatorToken::MODULUS) { + return BinaryExpression::modulus(leftValue, rightValue); + } else if (expressionNode->operation.type.operatorToken == + OperatorToken::POTENTIATION) { + return BinaryExpression::potentiation(leftValue, rightValue); + } else { + throw std::invalid_argument("Invalid operator operation: " + + expressionNode->operation.value); } + break; + case Token::TypeTag::SHORT_NOTATION: + break; + default: + throw std::invalid_argument("Invalid short operation: " + + expressionNode->operation.value); + } + throw std::invalid_argument("Invalid short operation: " + expressionNode->operation.value); } \ No newline at end of file From 3cc7518817918247f52d9d5c602fcf5e7d8c1502 Mon Sep 17 00:00:00 2001 From: marcelnoehre Date: Wed, 5 Feb 2025 12:44:56 +0100 Subject: [PATCH 3/9] map with short operation --- src/interpreter/data/array.cpp | 66 ++++++++++++++++++---------------- 1 file changed, 36 insertions(+), 30 deletions(-) diff --git a/src/interpreter/data/array.cpp b/src/interpreter/data/array.cpp index 2d5870e..b22d58f 100644 --- a/src/interpreter/data/array.cpp +++ b/src/interpreter/data/array.cpp @@ -907,39 +907,45 @@ Storage::DataWrapper Array::map(std::string method, Expr *caller, } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { - throw std::logic_error("Invalid arguments!"); - } - if (callbackFunction.data._callbackFunction->parameters.size() != 1) { - throw std::logic_error("Invalid number of parameters!"); - } - if (!(callbackFunction.data._callbackFunction->parameters[0].tag == - Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { - throw std::logic_error("Invalid parameter!"); - } - if (callerValue.data._array->empty()) { - return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::ARRAY, - new std::vector()); - } std::vector tmpElements = - std::vector(); - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - std::shared_ptr parameterStorage = std::make_shared(); - parameterStorage->setValue( - callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); - Storage::DataWrapper returnValue = - CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) - .executeBody(parameterStorage); - tmpElements.push_back(returnValue); + std::vector(); + if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + tmpElements.push_back(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i))); + } + } else { + if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { + throw std::logic_error("Invalid arguments!"); + } + if (callbackFunction.data._callbackFunction->parameters.size() != 1) { + throw std::logic_error("Invalid number of parameters!"); + } + if (!(callbackFunction.data._callbackFunction->parameters[0].tag == + Token::TypeTag::DATA && + callbackFunction.data._callbackFunction->parameters[0].type.dataToken == + DataToken::IDENTIFIER)) { + throw std::logic_error("Invalid parameter!"); + } + if (callerValue.data._array->empty()) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::ARRAY, + new std::vector()); + } + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + std::shared_ptr parameterStorage = std::make_shared(); + parameterStorage->setValue( + callbackFunction.data._callbackFunction->parameters[0].value, + callerValue.data._array->at(i)); + Storage::DataWrapper returnValue = + CallbackFunctionExpression(callbackFunction.data._callbackFunction, + storage) + .executeBody(parameterStorage); + tmpElements.push_back(returnValue); + } } return Storage::DataWrapper( - Storage::WrapperType::VALUE, Storage::DataType::ARRAY, - new std::vector(tmpElements)); + Storage::WrapperType::VALUE, Storage::DataType::ARRAY, + new std::vector(tmpElements)); } Storage::DataWrapper From df93f0aa63771c100063adbe901c3897a3e26ebe Mon Sep 17 00:00:00 2001 From: marcelnoehre Date: Wed, 5 Feb 2025 12:50:44 +0100 Subject: [PATCH 4/9] Short Notation for every and some --- src/interpreter/data/array.cpp | 131 +++++++++++++++++++-------------- 1 file changed, 77 insertions(+), 54 deletions(-) diff --git a/src/interpreter/data/array.cpp b/src/interpreter/data/array.cpp index b22d58f..2696ae4 100644 --- a/src/interpreter/data/array.cpp +++ b/src/interpreter/data/array.cpp @@ -595,38 +595,50 @@ Array::every(std::string method, Expr *caller, Storage::DataWrapper callerValue, } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { - throw std::logic_error("Invalid arguments!"); - } - if (callbackFunction.data._callbackFunction->parameters.size() != 1) { - throw std::logic_error("Invalid number of parameters!"); - } - if (!(callbackFunction.data._callbackFunction->parameters[0].tag == - Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { - throw std::logic_error("Invalid parameter!"); - } - if (callerValue.data._array->empty()) { + + if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + if (!checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::BOOLEAN, false); + } + } return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, true); - } - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - std::shared_ptr parameterStorage = std::make_shared(); - parameterStorage->setValue( - callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); - Storage::DataWrapper returnValue = - CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) - .executeBody(parameterStorage); - if (!checkTrueishness(returnValue, storage)) { + } else { + if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { + throw std::logic_error("Invalid arguments!"); + } + if (callbackFunction.data._callbackFunction->parameters.size() != 1) { + throw std::logic_error("Invalid number of parameters!"); + } + if (!(callbackFunction.data._callbackFunction->parameters[0].tag == + Token::TypeTag::DATA && + callbackFunction.data._callbackFunction->parameters[0].type.dataToken == + DataToken::IDENTIFIER)) { + throw std::logic_error("Invalid parameter!"); + } + if (callerValue.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::BOOLEAN, false); + Storage::DataType::BOOLEAN, true); + } + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + std::shared_ptr parameterStorage = std::make_shared(); + parameterStorage->setValue( + callbackFunction.data._callbackFunction->parameters[0].value, + callerValue.data._array->at(i)); + Storage::DataWrapper returnValue = + CallbackFunctionExpression(callbackFunction.data._callbackFunction, + storage) + .executeBody(parameterStorage); + if (!checkTrueishness(returnValue, storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::BOOLEAN, false); + } } + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::BOOLEAN, true); } - return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::BOOLEAN, true); } Storage::DataWrapper @@ -638,38 +650,49 @@ Array::some(std::string method, Expr *caller, Storage::DataWrapper callerValue, } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { - throw std::logic_error("Invalid arguments!"); - } - if (callbackFunction.data._callbackFunction->parameters.size() != 1) { - throw std::logic_error("Invalid number of parameters!"); - } - if (!(callbackFunction.data._callbackFunction->parameters[0].tag == - Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { - throw std::logic_error("Invalid parameter!"); - } - if (callerValue.data._array->empty()) { + if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::BOOLEAN, true); + } + } return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, false); - } - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - std::shared_ptr parameterStorage = std::make_shared(); - parameterStorage->setValue( - callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); - Storage::DataWrapper returnValue = - CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) - .executeBody(parameterStorage); - if (checkTrueishness(returnValue, storage)) { + } else { + if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { + throw std::logic_error("Invalid arguments!"); + } + if (callbackFunction.data._callbackFunction->parameters.size() != 1) { + throw std::logic_error("Invalid number of parameters!"); + } + if (!(callbackFunction.data._callbackFunction->parameters[0].tag == + Token::TypeTag::DATA && + callbackFunction.data._callbackFunction->parameters[0].type.dataToken == + DataToken::IDENTIFIER)) { + throw std::logic_error("Invalid parameter!"); + } + if (callerValue.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::BOOLEAN, true); + Storage::DataType::BOOLEAN, false); } + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + std::shared_ptr parameterStorage = std::make_shared(); + parameterStorage->setValue( + callbackFunction.data._callbackFunction->parameters[0].value, + callerValue.data._array->at(i)); + Storage::DataWrapper returnValue = + CallbackFunctionExpression(callbackFunction.data._callbackFunction, + storage) + .executeBody(parameterStorage); + if (checkTrueishness(returnValue, storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::BOOLEAN, true); + } + } + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::BOOLEAN, false); } - return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::BOOLEAN, false); } Storage::DataWrapper From ee457e0013436794c8b3780b8f90ce2bda811ec5 Mon Sep 17 00:00:00 2001 From: marcelnoehre Date: Wed, 5 Feb 2025 13:36:51 +0100 Subject: [PATCH 5/9] Short Notation for find, findIndex, findLast, findLastIndex --- src/interpreter/data/array.cpp | 263 +++++++++++++++++++-------------- 1 file changed, 150 insertions(+), 113 deletions(-) diff --git a/src/interpreter/data/array.cpp b/src/interpreter/data/array.cpp index 2696ae4..6275ae0 100644 --- a/src/interpreter/data/array.cpp +++ b/src/interpreter/data/array.cpp @@ -595,7 +595,6 @@ Array::every(std::string method, Expr *caller, Storage::DataWrapper callerValue, } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { if (!checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { @@ -702,37 +701,47 @@ Array::find(std::string method, Expr *caller, Storage::DataWrapper callerValue, if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - Storage::DataWrapper callbackFunction = - Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { - throw std::logic_error("Invalid arguments!"); - } - if (callbackFunction.data._callbackFunction->parameters.size() != 1) { - throw std::logic_error("Invalid number of parameters!"); - } - if (!(callbackFunction.data._callbackFunction->parameters[0].tag == - Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { - throw std::logic_error("Invalid parameter!"); - } if (callerValue.data._array->empty()) { - return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::_NULL, 0); - } - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - std::shared_ptr parameterStorage = std::make_shared(); - parameterStorage->setValue( - callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); - Storage::DataWrapper returnValue = - CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) - .executeBody(parameterStorage); - if (checkTrueishness(returnValue, storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, - callerValue.data._array->at(i).dataType, - callerValue.data._array->at(i).data); + Storage::DataType::_NULL, 0); + } + Storage::DataWrapper callbackFunction = + Expression(args[0].get(), storage).execute(); + if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + callerValue.data._array->at(i).dataType, + callerValue.data._array->at(i).data); + } + } + } else { + if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { + throw std::logic_error("Invalid arguments!"); + } + if (callbackFunction.data._callbackFunction->parameters.size() != 1) { + throw std::logic_error("Invalid number of parameters!"); + } + if (!(callbackFunction.data._callbackFunction->parameters[0].tag == + Token::TypeTag::DATA && + callbackFunction.data._callbackFunction->parameters[0].type.dataToken == + DataToken::IDENTIFIER)) { + throw std::logic_error("Invalid parameter!"); + } + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + std::shared_ptr parameterStorage = std::make_shared(); + parameterStorage->setValue( + callbackFunction.data._callbackFunction->parameters[0].value, + callerValue.data._array->at(i)); + Storage::DataWrapper returnValue = + CallbackFunctionExpression(callbackFunction.data._callbackFunction, + storage) + .executeBody(parameterStorage); + if (checkTrueishness(returnValue, storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + callerValue.data._array->at(i).dataType, + callerValue.data._array->at(i).data); + } } } return Storage::DataWrapper(Storage::WrapperType::VALUE, @@ -747,36 +756,44 @@ Array::findIndex(std::string method, Expr *caller, if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - Storage::DataWrapper callbackFunction = - Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { - throw std::logic_error("Invalid arguments!"); - } - if (callbackFunction.data._callbackFunction->parameters.size() != 1) { - throw std::logic_error("Invalid number of parameters!"); - } - if (!(callbackFunction.data._callbackFunction->parameters[0].tag == - Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { - throw std::logic_error("Invalid parameter!"); - } if (callerValue.data._array->empty()) { - return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::INTEGER, -1); - } - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - std::shared_ptr parameterStorage = std::make_shared(); - parameterStorage->setValue( - callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); - Storage::DataWrapper returnValue = - CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) - .executeBody(parameterStorage); - if (checkTrueishness(returnValue, storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::INTEGER, i); + Storage::DataType::INTEGER, -1); + } + Storage::DataWrapper callbackFunction = + Expression(args[0].get(), storage).execute(); + if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::INTEGER, i); + } + } + } else { + if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { + throw std::logic_error("Invalid arguments!"); + } + if (callbackFunction.data._callbackFunction->parameters.size() != 1) { + throw std::logic_error("Invalid number of parameters!"); + } + if (!(callbackFunction.data._callbackFunction->parameters[0].tag == + Token::TypeTag::DATA && + callbackFunction.data._callbackFunction->parameters[0].type.dataToken == + DataToken::IDENTIFIER)) { + throw std::logic_error("Invalid parameter!"); + } + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + std::shared_ptr parameterStorage = std::make_shared(); + parameterStorage->setValue( + callbackFunction.data._callbackFunction->parameters[0].value, + callerValue.data._array->at(i)); + Storage::DataWrapper returnValue = + CallbackFunctionExpression(callbackFunction.data._callbackFunction, + storage) + .executeBody(parameterStorage); + if (checkTrueishness(returnValue, storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::INTEGER, i); + } } } return Storage::DataWrapper(Storage::WrapperType::VALUE, @@ -791,38 +808,49 @@ Array::findLast(std::string method, Expr *caller, if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - Storage::DataWrapper callbackFunction = - Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { - throw std::logic_error("Invalid arguments!"); - } - if (callbackFunction.data._callbackFunction->parameters.size() != 1) { - throw std::logic_error("Invalid number of parameters!"); - } - if (!(callbackFunction.data._callbackFunction->parameters[0].tag == - Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { - throw std::logic_error("Invalid parameter!"); - } if (callerValue.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::_NULL, 0); } - for (int i = static_cast(callerValue.data._array->size()) - 1; i >= 0; - --i) { - std::shared_ptr parameterStorage = std::make_shared(); - parameterStorage->setValue( - callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); - Storage::DataWrapper returnValue = - CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) - .executeBody(parameterStorage); - if (checkTrueishness(returnValue, storage)) { - return Storage::DataWrapper(Storage::WrapperType::VALUE, - callerValue.data._array->at(i).dataType, - callerValue.data._array->at(i).data); + Storage::DataWrapper callbackFunction = + Expression(args[0].get(), storage).execute(); + if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + for (int i = static_cast(callerValue.data._array->size()) - 1; i >= 0; + --i) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + callerValue.data._array->at(i).dataType, + callerValue.data._array->at(i).data); + } + } + } else { + if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { + throw std::logic_error("Invalid arguments!"); + } + if (callbackFunction.data._callbackFunction->parameters.size() != 1) { + throw std::logic_error("Invalid number of parameters!"); + } + if (!(callbackFunction.data._callbackFunction->parameters[0].tag == + Token::TypeTag::DATA && + callbackFunction.data._callbackFunction->parameters[0].type.dataToken == + DataToken::IDENTIFIER)) { + throw std::logic_error("Invalid parameter!"); + } + for (int i = static_cast(callerValue.data._array->size()) - 1; i >= 0; + --i) { + std::shared_ptr parameterStorage = std::make_shared(); + parameterStorage->setValue( + callbackFunction.data._callbackFunction->parameters[0].value, + callerValue.data._array->at(i)); + Storage::DataWrapper returnValue = + CallbackFunctionExpression(callbackFunction.data._callbackFunction, + storage) + .executeBody(parameterStorage); + if (checkTrueishness(returnValue, storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + callerValue.data._array->at(i).dataType, + callerValue.data._array->at(i).data); + } } } return Storage::DataWrapper(Storage::WrapperType::VALUE, @@ -837,37 +865,46 @@ Array::findLastIndex(std::string method, Expr *caller, if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - Storage::DataWrapper callbackFunction = - Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { - throw std::logic_error("Invalid arguments!"); - } - if (callbackFunction.data._callbackFunction->parameters.size() != 1) { - throw std::logic_error("Invalid number of parameters!"); - } - if (!(callbackFunction.data._callbackFunction->parameters[0].tag == - Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { - throw std::logic_error("Invalid parameter!"); - } if (callerValue.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::INTEGER, -1); } - for (int i = static_cast(callerValue.data._array->size()) - 1; i >= 0; - --i) { - std::shared_ptr parameterStorage = std::make_shared(); - parameterStorage->setValue( - callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); - Storage::DataWrapper returnValue = - CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) - .executeBody(parameterStorage); - if (checkTrueishness(returnValue, storage)) { - return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::INTEGER, i); + Storage::DataWrapper callbackFunction = + Expression(args[0].get(), storage).execute(); + if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + for (int i = static_cast(callerValue.data._array->size()) - 1; i >= 0; + --i) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::INTEGER, i); + } + } + } else { + if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { + throw std::logic_error("Invalid arguments!"); + } + if (callbackFunction.data._callbackFunction->parameters.size() != 1) { + throw std::logic_error("Invalid number of parameters!"); + } + if (!(callbackFunction.data._callbackFunction->parameters[0].tag == + Token::TypeTag::DATA && + callbackFunction.data._callbackFunction->parameters[0].type.dataToken == + DataToken::IDENTIFIER)) { + throw std::logic_error("Invalid parameter!"); + } + for (int i = static_cast(callerValue.data._array->size()) - 1; i >= 0; + --i) { + std::shared_ptr parameterStorage = std::make_shared(); + parameterStorage->setValue( + callbackFunction.data._callbackFunction->parameters[0].value, + callerValue.data._array->at(i)); + Storage::DataWrapper returnValue = + CallbackFunctionExpression(callbackFunction.data._callbackFunction, + storage) + .executeBody(parameterStorage); + if (checkTrueishness(returnValue, storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::INTEGER, i); + } } } return Storage::DataWrapper(Storage::WrapperType::VALUE, From 14febebf625b970585fb003fc604f8cdb2de8eed Mon Sep 17 00:00:00 2001 From: marcelnoehre Date: Wed, 5 Feb 2025 13:48:55 +0100 Subject: [PATCH 6/9] Short Notation for filter --- src/interpreter/data/array.cpp | 60 +++++++++++++++++++--------------- 1 file changed, 34 insertions(+), 26 deletions(-) diff --git a/src/interpreter/data/array.cpp b/src/interpreter/data/array.cpp index 6275ae0..4cb65f6 100644 --- a/src/interpreter/data/array.cpp +++ b/src/interpreter/data/array.cpp @@ -919,38 +919,46 @@ Array::filter(std::string method, Expr *caller, if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - Storage::DataWrapper callbackFunction = - Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { - throw std::logic_error("Invalid arguments!"); - } - if (callbackFunction.data._callbackFunction->parameters.size() != 1) { - throw std::logic_error("Invalid number of parameters!"); - } - if (!(callbackFunction.data._callbackFunction->parameters[0].tag == - Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { - throw std::logic_error("Invalid parameter!"); - } if (callerValue.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::ARRAY, new std::vector()); } + Storage::DataWrapper callbackFunction = + Expression(args[0].get(), storage).execute(); std::vector tmpElements = - std::vector(); - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - std::shared_ptr parameterStorage = std::make_shared(); - parameterStorage->setValue( - callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); - Storage::DataWrapper returnValue = - CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) - .executeBody(parameterStorage); - if (checkTrueishness(returnValue, storage)) { - tmpElements.push_back(callerValue.data._array->at(i)); + std::vector(); + if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + tmpElements.push_back(callerValue.data._array->at(i)); + } + } + } else { + if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { + throw std::logic_error("Invalid arguments!"); + } + if (callbackFunction.data._callbackFunction->parameters.size() != 1) { + throw std::logic_error("Invalid number of parameters!"); + } + if (!(callbackFunction.data._callbackFunction->parameters[0].tag == + Token::TypeTag::DATA && + callbackFunction.data._callbackFunction->parameters[0].type.dataToken == + DataToken::IDENTIFIER)) { + throw std::logic_error("Invalid parameter!"); + } + for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + std::shared_ptr parameterStorage = std::make_shared(); + parameterStorage->setValue( + callbackFunction.data._callbackFunction->parameters[0].value, + callerValue.data._array->at(i)); + Storage::DataWrapper returnValue = + CallbackFunctionExpression(callbackFunction.data._callbackFunction, + storage) + .executeBody(parameterStorage); + if (checkTrueishness(returnValue, storage)) { + tmpElements.push_back(callerValue.data._array->at(i)); + } } } return Storage::DataWrapper( From ebea13672707e60c70b740ab7d32f451bbf4ac12 Mon Sep 17 00:00:00 2001 From: marcelnoehre Date: Wed, 5 Feb 2025 23:17:46 +0100 Subject: [PATCH 7/9] refcator array handling --- include/interpreter/data/array.hpp | 101 ++--- src/interpreter/data/array.cpp | 423 +++++++++--------- .../expressions/binary_expression.cpp | 4 +- .../expressions/call_expression.cpp | 9 +- 4 files changed, 245 insertions(+), 292 deletions(-) diff --git a/include/interpreter/data/array.hpp b/include/interpreter/data/array.hpp index 35cf877..9e5b147 100644 --- a/include/interpreter/data/array.hpp +++ b/include/interpreter/data/array.hpp @@ -44,9 +44,9 @@ enum class ArrayMethod { class Array { public: Storage::DataWrapper - callMethod(std::string method, Expr *caller, + callMethod(std::string method, Storage::DataWrapper caller, const std::vector> args, - std::vector> storage); + std::vector> storage, std::string identifier); private: inline static const std::unordered_map @@ -78,114 +78,87 @@ class Array { {"flatMap", ArrayMethod::FLAT_MAP}, {"forEach", ArrayMethod::FOR_EACH}}; - Storage::DataWrapper length(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper length(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper push(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper push(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage); - Storage::DataWrapper pop(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + std::vector> storage, std::string identifier); + Storage::DataWrapper pop(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage); - Storage::DataWrapper shift(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + std::vector> storage, std::string identifier); + Storage::DataWrapper shift(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage); - Storage::DataWrapper unshift(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + std::vector> storage, std::string identifier); + Storage::DataWrapper unshift(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage); - Storage::DataWrapper splice(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + std::vector> storage, std::string identifier); + Storage::DataWrapper splice(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage); - Storage::DataWrapper reverse(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + std::vector> storage, std::string identifier); + Storage::DataWrapper reverse(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage); - Storage::DataWrapper sort(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + std::vector> storage, std::string identifier); + Storage::DataWrapper sort(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage); - Storage::DataWrapper fill(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + std::vector> storage, std::string identifier); + Storage::DataWrapper fill(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage); - Storage::DataWrapper concat(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + std::vector> storage, std::string identifier); + Storage::DataWrapper concat(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper slice(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper slice(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper includes(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper includes(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper indexOf(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper indexOf(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); Storage::DataWrapper - lastIndexOf(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + lastIndexOf(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper join(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper join(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper every(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper every(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper some(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper some(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper find(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper find(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper findIndex(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper findIndex(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper findLast(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper findLast(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); Storage::DataWrapper - findLastIndex(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + findLastIndex(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper filter(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper filter(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper map(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper map(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper reduce(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper reduce(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper flat(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper flat(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper flatMap(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper flatMap(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper forEach(std::string method, Expr *caller, - Storage::DataWrapper callerValue, + Storage::DataWrapper forEach(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); diff --git a/src/interpreter/data/array.cpp b/src/interpreter/data/array.cpp index 4cb65f6..da7e723 100644 --- a/src/interpreter/data/array.cpp +++ b/src/interpreter/data/array.cpp @@ -1,75 +1,71 @@ #include "interpreter/data/array.hpp" Storage::DataWrapper -Array::callMethod(std::string method, Expr *caller, +Array::callMethod(std::string method, Storage::DataWrapper caller, const std::vector> args, - std::vector> storage) { - ; - Storage::DataWrapper callerValue = Expression(caller, storage).execute(); - + std::vector> storage, std::string identifier) { switch (stringToEnumMap.at(method)) { case ArrayMethod::LENGTH: - return length(method, caller, callerValue, args, storage); + return length(method, caller, args, storage); case ArrayMethod::PUSH: - return push(method, caller, callerValue, args, storage); + return push(method, caller, args, storage, identifier); case ArrayMethod::POP: - return pop(method, caller, callerValue, args, storage); + return pop(method, caller, args, storage, identifier); case ArrayMethod::SHIFT: - return shift(method, caller, callerValue, args, storage); + return shift(method, caller, args, storage, identifier); case ArrayMethod::UNSHIFT: - return unshift(method, caller, callerValue, args, storage); + return unshift(method, caller, args, storage, identifier); case ArrayMethod::SPLICE: - return splice(method, caller, callerValue, args, storage); + return splice(method, caller, args, storage, identifier); case ArrayMethod::REVERSE: - return reverse(method, caller, callerValue, args, storage); + return reverse(method, caller, args, storage, identifier); case ArrayMethod::SORT: - return sort(method, caller, callerValue, args, storage); + return sort(method, caller, args, storage, identifier); case ArrayMethod::FILL: - return fill(method, caller, callerValue, args, storage); + return fill(method, caller, args, storage, identifier); case ArrayMethod::CONCAT: - return concat(method, caller, callerValue, args, storage); + return concat(method, caller, args, storage); case ArrayMethod::SLICE: - return slice(method, caller, callerValue, args, storage); + return slice(method, caller, args, storage); case ArrayMethod::INCLUDES: - return includes(method, caller, callerValue, args, storage); + return includes(method, caller, args, storage); case ArrayMethod::INDEX_OF: - return indexOf(method, caller, callerValue, args, storage); + return indexOf(method, caller, args, storage); case ArrayMethod::LAST_INDEX_OF: - return lastIndexOf(method, caller, callerValue, args, storage); + return lastIndexOf(method, caller, args, storage); case ArrayMethod::JOIN: - return join(method, caller, callerValue, args, storage); + return join(method, caller, args, storage); case ArrayMethod::EVERY: - return every(method, caller, callerValue, args, storage); + return every(method, caller, args, storage); case ArrayMethod::SOME: - return some(method, caller, callerValue, args, storage); + return some(method, caller, args, storage); case ArrayMethod::FIND: - return find(method, caller, callerValue, args, storage); + return find(method, caller, args, storage); case ArrayMethod::FIND_INDEX: - return findIndex(method, caller, callerValue, args, storage); + return findIndex(method, caller, args, storage); case ArrayMethod::FIND_LAST: - return findLast(method, caller, callerValue, args, storage); + return findLast(method, caller, args, storage); case ArrayMethod::FIND_LAST_INDEX: - return findLastIndex(method, caller, callerValue, args, storage); + return findLastIndex(method, caller, args, storage); case ArrayMethod::FILTER: - return filter(method, caller, callerValue, args, storage); + return filter(method, caller, args, storage); case ArrayMethod::MAP: - return map(method, caller, callerValue, args, storage); + return map(method, caller, args, storage); case ArrayMethod::REDUCE: - return reduce(method, caller, callerValue, args, storage); + return reduce(method, caller, args, storage); case ArrayMethod::FLAT: - return flat(method, caller, callerValue, args, storage); + return flat(method, caller, args, storage); case ArrayMethod::FLAT_MAP: - return flatMap(method, caller, callerValue, args, storage); + return flatMap(method, caller, args, storage); case ArrayMethod::FOR_EACH: - return forEach(method, caller, callerValue, args, storage); + return forEach(method, caller, args, storage); default: throw std::runtime_error("Invalid array method!"); } } Storage::DataWrapper -Array::length(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::length(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 0) { @@ -77,105 +73,100 @@ Array::length(std::string method, Expr *caller, } return Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::INTEGER, - static_cast(callerValue.data._array->size())); + static_cast(caller.data._array->size())); } Storage::DataWrapper -Array::push(std::string method, Expr *caller, Storage::DataWrapper callerValue, +Array::push(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage) { + std::vector> storage, std::string identifier) { if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - callerValue.data._array->push_back( + caller.data._array->push_back( Expression(args[0].get(), storage).execute()); - if (auto expr = dynamic_cast(caller)) { - int keyIndex = storageKeyIndex(storage, expr->identifier.value); + if (!identifier.empty()) { + int keyIndex = storageKeyIndex(storage, identifier); if (keyIndex == -1) { throw std::logic_error("Variable not declared."); } - storage[keyIndex]->updateValue(expr->identifier.value, callerValue); + storage[keyIndex]->updateValue(identifier, caller); } return Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::INTEGER, - static_cast(callerValue.data._array->size())); + static_cast(caller.data._array->size())); } -Storage::DataWrapper Array::pop(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Storage::DataWrapper Array::pop(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage) { + std::vector> storage, std::string identifier) { Storage::DataWrapper tmpValue = Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::_NULL, 0); if (args.size() != 0) { throw std::logic_error("Invalid number of arguments!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return tmpValue; } - tmpValue = callerValue.data._array->back(); - callerValue.data._array->pop_back(); - if (auto expr = dynamic_cast(caller)) { - int keyIndex = storageKeyIndex(storage, expr->identifier.value); + tmpValue = caller.data._array->back(); + caller.data._array->pop_back(); + if (!identifier.empty()) { + int keyIndex = storageKeyIndex(storage, identifier); if (keyIndex == -1) { throw std::logic_error("Variable not declared."); } - storage[keyIndex]->updateValue(expr->identifier.value, callerValue); + storage[keyIndex]->updateValue(identifier, caller); } return tmpValue; } Storage::DataWrapper -Array::shift(std::string method, Expr *caller, Storage::DataWrapper callerValue, +Array::shift(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage) { + std::vector> storage, std::string identifier) { Storage::DataWrapper tmpValue = Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::_NULL, 0); if (args.size() != 0) { throw std::logic_error("Invalid number of arguments!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return tmpValue; } - tmpValue = callerValue.data._array->front(); - callerValue.data._array->erase(callerValue.data._array->begin()); - if (auto expr = dynamic_cast(caller)) { - int keyIndex = storageKeyIndex(storage, expr->identifier.value); + tmpValue = caller.data._array->front(); + caller.data._array->erase(caller.data._array->begin()); + if (!identifier.empty()) { + int keyIndex = storageKeyIndex(storage, identifier); if (keyIndex == -1) { throw std::logic_error("Variable not declared."); } - storage[keyIndex]->updateValue(expr->identifier.value, callerValue); + storage[keyIndex]->updateValue(identifier, caller); } return tmpValue; } -Storage::DataWrapper -Array::unshift(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Storage::DataWrapper Array::unshift(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage) { + std::vector> storage, std::string identifier) { if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - callerValue.data._array->insert(callerValue.data._array->begin(), + caller.data._array->insert(caller.data._array->begin(), Expression(args[0].get(), storage).execute()); - if (auto expr = dynamic_cast(caller)) { - int keyIndex = storageKeyIndex(storage, expr->identifier.value); + if (!identifier.empty()) { + int keyIndex = storageKeyIndex(storage, identifier); if (keyIndex == -1) { throw std::logic_error("Variable not declared."); } - storage[keyIndex]->updateValue(expr->identifier.value, callerValue); + storage[keyIndex]->updateValue(identifier, caller); } return Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::INTEGER, - static_cast(callerValue.data._array->size())); + static_cast(caller.data._array->size())); } -Storage::DataWrapper -Array::splice(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Storage::DataWrapper Array::splice(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage) { + std::vector> storage, std::string identifier) { Storage::DataWrapper tmpValue = Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::_NULL, 0); std::vector tmpElements, tmpDeletedElements; @@ -183,7 +174,7 @@ Array::splice(std::string method, Expr *caller, if (args.size() < 2 || args.size() > 3) { throw std::logic_error("Invalid number of arguments!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return tmpValue; } if (Expression(args[0].get(), storage).execute().dataType != @@ -198,7 +189,7 @@ Array::splice(std::string method, Expr *caller, tmpElements = *(Expression(args[2].get(), storage).execute().data._array); } if (start < 0) { - start = static_cast(callerValue.data._array->size()) + start; + start = static_cast(caller.data._array->size()) + start; } if (start < 0) { start = 0; @@ -206,62 +197,60 @@ Array::splice(std::string method, Expr *caller, if (count < 0) { count = 0; } - if (start > static_cast(callerValue.data._array->size())) { - start = static_cast(callerValue.data._array->size()); + if (start > static_cast(caller.data._array->size())) { + start = static_cast(caller.data._array->size()); } - if (count > static_cast(callerValue.data._array->size()) - start) { - count = static_cast(callerValue.data._array->size()) - start; + if (count > static_cast(caller.data._array->size()) - start) { + count = static_cast(caller.data._array->size()) - start; } for (int i = 0; i < count; ++i) { - tmpDeletedElements.push_back(callerValue.data._array->at(start + i)); + tmpDeletedElements.push_back(caller.data._array->at(start + i)); } - callerValue.data._array->erase(callerValue.data._array->begin() + start, - callerValue.data._array->begin() + start + + caller.data._array->erase(caller.data._array->begin() + start, + caller.data._array->begin() + start + count); for (int i = 0; i < static_cast(tmpElements.size()); ++i) { - callerValue.data._array->insert( - callerValue.data._array->begin() + start + i, tmpElements[i]); + caller.data._array->insert( + caller.data._array->begin() + start + i, tmpElements[i]); } - if (auto expr = dynamic_cast(caller)) { - int keyIndex = storageKeyIndex(storage, expr->identifier.value); + if (!identifier.empty()) { + int keyIndex = storageKeyIndex(storage, identifier); if (keyIndex == -1) { throw std::logic_error("Variable not declared."); } - storage[keyIndex]->updateValue(expr->identifier.value, callerValue); + storage[keyIndex]->updateValue(identifier, caller); } return Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::ARRAY, new std::vector(tmpDeletedElements)); } -Storage::DataWrapper -Array::reverse(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Storage::DataWrapper Array::reverse(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage) { + std::vector> storage, std::string identifier) { if (args.size() != 0) { throw std::logic_error("Invalid number of arguments!"); } - std::reverse(callerValue.data._array->begin(), - callerValue.data._array->end()); - if (auto expr = dynamic_cast(caller)) { - int keyIndex = storageKeyIndex(storage, expr->identifier.value); + std::reverse(caller.data._array->begin(), + caller.data._array->end()); + if (!identifier.empty()) { + int keyIndex = storageKeyIndex(storage, identifier); if (keyIndex == -1) { throw std::logic_error("Variable not declared."); } - storage[keyIndex]->updateValue(expr->identifier.value, callerValue); + storage[keyIndex]->updateValue(identifier, caller); } - return callerValue; + return caller; } Storage::DataWrapper -Array::sort(std::string method, Expr *caller, Storage::DataWrapper callerValue, +Array::sort(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage) { + std::vector> storage, std::string identifier) { if (args.size() != 0) { throw std::logic_error("Invalid number of arguments!"); } - std::sort(callerValue.data._array->begin(), callerValue.data._array->end(), + std::sort(caller.data._array->begin(), caller.data._array->end(), [](const Storage::DataWrapper &a, const Storage::DataWrapper &b) { if (a.dataType != b.dataType) { return a.dataType < b.dataType; @@ -291,20 +280,27 @@ Array::sort(std::string method, Expr *caller, Storage::DataWrapper callerValue, throw std::runtime_error("Unknown data type!"); } }); - return callerValue; + if (!identifier.empty()) { + int keyIndex = storageKeyIndex(storage, identifier); + if (keyIndex == -1) { + throw std::logic_error("Variable not declared."); + } + storage[keyIndex]->updateValue(identifier, caller); + } + return caller; } Storage::DataWrapper -Array::fill(std::string method, Expr *caller, Storage::DataWrapper callerValue, +Array::fill(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage) { + std::vector> storage, std::string identifier) { Storage::DataWrapper tmpValue = Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::_NULL, 0); int start, end; if (args.size() < 1 || args.size() > 3) { throw std::logic_error("Invalid number of arguments!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return tmpValue; } if (Expression(args[0].get(), storage).execute().dataType != @@ -335,31 +331,30 @@ Array::fill(std::string method, Expr *caller, Storage::DataWrapper callerValue, } if (args.size() == 1) { start = 0; - end = static_cast(callerValue.data._array->size()); + end = static_cast(caller.data._array->size()); } else if (args.size() == 2) { start = Expression(args[1].get(), storage).execute().data._int; - end = static_cast(callerValue.data._array->size()); + end = static_cast(caller.data._array->size()); } else { start = Expression(args[1].get(), storage).execute().data._int; end = Expression(args[2].get(), storage).execute().data._int; } for (int i = start; i < end; ++i) { - callerValue.data._array->at(i) = + caller.data._array->at(i) = Expression(args[0].get(), storage).execute(); } - if (auto expr = dynamic_cast(caller)) { - int keyIndex = storageKeyIndex(storage, expr->identifier.value); + if (!identifier.empty()) { + int keyIndex = storageKeyIndex(storage, identifier); if (keyIndex == -1) { throw std::logic_error("Variable not declared."); } - storage[keyIndex]->updateValue(expr->identifier.value, callerValue); + storage[keyIndex]->updateValue(identifier, caller); } - return callerValue; + return caller; } Storage::DataWrapper -Array::concat(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::concat(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { @@ -374,21 +369,14 @@ Array::concat(std::string method, Expr *caller, static_cast( Expression(args[0].get(), storage).execute().data._array->size()); ++i) { - callerValue.data._array->push_back( + caller.data._array->push_back( Expression(args[0].get(), storage).execute().data._array->at(i)); } - if (auto expr = dynamic_cast(caller)) { - int keyIndex = storageKeyIndex(storage, expr->identifier.value); - if (keyIndex == -1) { - throw std::logic_error("Variable not declared."); - } - storage[keyIndex]->updateValue(expr->identifier.value, callerValue); - } - return callerValue; + return caller; } Storage::DataWrapper -Array::slice(std::string method, Expr *caller, Storage::DataWrapper callerValue, +Array::slice(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { Storage::DataWrapper tmpValue = Storage::DataWrapper( @@ -396,7 +384,7 @@ Array::slice(std::string method, Expr *caller, Storage::DataWrapper callerValue, std::vector tmpElements; int start, end; if (args.size() == 0) { - return callerValue; + return caller; } if (args.size() > 2) { throw std::logic_error("Invalid number of arguments!"); @@ -412,20 +400,20 @@ Array::slice(std::string method, Expr *caller, Storage::DataWrapper callerValue, throw std::logic_error("Invalid arguments!"); } if (Expression(args[0].get(), storage).execute().data._int < 0) { - start = static_cast(callerValue.data._array->size()) + + start = static_cast(caller.data._array->size()) + Expression(args[0].get(), storage).execute().data._int; } else if (Expression(args[0].get(), storage).execute().data._int > - static_cast(callerValue.data._array->size())) { + static_cast(caller.data._array->size())) { return tmpValue; } else { start = Expression(args[0].get(), storage).execute().data._int; } if (args.size() == 1 || Expression(args[1].get(), storage).execute().data._int > - static_cast(callerValue.data._array->size())) { - end = static_cast(callerValue.data._array->size()); + static_cast(caller.data._array->size())) { + end = static_cast(caller.data._array->size()); } else if (Expression(args[1].get(), storage).execute().data._int < 0) { - end = static_cast(callerValue.data._array->size()) + + end = static_cast(caller.data._array->size()) + Expression(args[1].get(), storage).execute().data._int; } else { end = Expression(args[1].get(), storage).execute().data._int; @@ -434,7 +422,7 @@ Array::slice(std::string method, Expr *caller, Storage::DataWrapper callerValue, return tmpValue; } for (int i = start; i < end; ++i) { - tmpElements.push_back(callerValue.data._array->at(i)); + tmpElements.push_back(caller.data._array->at(i)); } return Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::ARRAY, @@ -442,8 +430,7 @@ Array::slice(std::string method, Expr *caller, Storage::DataWrapper callerValue, } Storage::DataWrapper -Array::includes(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::includes(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { @@ -469,8 +456,8 @@ Array::includes(std::string method, Expr *caller, Storage::DataType::_NULL) { throw std::logic_error("Invalid arguments!"); } - for (int i = 0; i < callerValue.data._array->size(); ++i) { - if (callerValue.data._array->at(i).equals( + for (int i = 0; i < caller.data._array->size(); ++i) { + if (caller.data._array->at(i).equals( Expression(args[0].get(), storage).execute())) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, true); @@ -481,8 +468,7 @@ Array::includes(std::string method, Expr *caller, } Storage::DataWrapper -Array::indexOf(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::indexOf(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { @@ -508,8 +494,8 @@ Array::indexOf(std::string method, Expr *caller, Storage::DataType::_NULL) { throw std::logic_error("Invalid arguments!"); } - for (int i = 0; i < callerValue.data._array->size(); ++i) { - if (callerValue.data._array->at(i).equals( + for (int i = 0; i < caller.data._array->size(); ++i) { + if (caller.data._array->at(i).equals( Expression(args[0].get(), storage).execute())) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::INTEGER, i); @@ -520,8 +506,7 @@ Array::indexOf(std::string method, Expr *caller, } Storage::DataWrapper -Array::lastIndexOf(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::lastIndexOf(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { @@ -547,9 +532,9 @@ Array::lastIndexOf(std::string method, Expr *caller, Storage::DataType::_NULL) { throw std::logic_error("Invalid arguments!"); } - for (int i = static_cast(callerValue.data._array->size()) - 1; i >= 0; + for (int i = static_cast(caller.data._array->size()) - 1; i >= 0; --i) { - if (callerValue.data._array->at(i).equals( + if (caller.data._array->at(i).equals( Expression(args[0].get(), storage).execute())) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::INTEGER, i); @@ -560,7 +545,7 @@ Array::lastIndexOf(std::string method, Expr *caller, } Storage::DataWrapper -Array::join(std::string method, Expr *caller, Storage::DataWrapper callerValue, +Array::join(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() > 1) { @@ -575,11 +560,11 @@ Array::join(std::string method, Expr *caller, Storage::DataWrapper callerValue, separator = *(Expression(args[0].get(), storage).execute().data._string); } std::string result = ""; - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { if (i != 0) { result += separator; } - result += getPrintableValue(callerValue.data._array->at(i)); + result += getPrintableValue(caller.data._array->at(i)); } return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::STRING, @@ -587,7 +572,7 @@ Array::join(std::string method, Expr *caller, Storage::DataWrapper callerValue, } Storage::DataWrapper -Array::every(std::string method, Expr *caller, Storage::DataWrapper callerValue, +Array::every(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { @@ -596,8 +581,8 @@ Array::every(std::string method, Expr *caller, Storage::DataWrapper callerValue, Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - if (!checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { + if (!checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, false); } @@ -617,15 +602,15 @@ Array::every(std::string method, Expr *caller, Storage::DataWrapper callerValue, DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, true); } - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); + caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, storage) @@ -641,7 +626,7 @@ Array::every(std::string method, Expr *caller, Storage::DataWrapper callerValue, } Storage::DataWrapper -Array::some(std::string method, Expr *caller, Storage::DataWrapper callerValue, +Array::some(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { @@ -650,8 +635,8 @@ Array::some(std::string method, Expr *caller, Storage::DataWrapper callerValue, Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, true); } @@ -671,15 +656,15 @@ Array::some(std::string method, Expr *caller, Storage::DataWrapper callerValue, DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, false); } - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); + caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, storage) @@ -695,24 +680,24 @@ Array::some(std::string method, Expr *caller, Storage::DataWrapper callerValue, } Storage::DataWrapper -Array::find(std::string method, Expr *caller, Storage::DataWrapper callerValue, +Array::find(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::_NULL, 0); } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, - callerValue.data._array->at(i).dataType, - callerValue.data._array->at(i).data); + caller.data._array->at(i).dataType, + caller.data._array->at(i).data); } } } else { @@ -728,19 +713,19 @@ Array::find(std::string method, Expr *caller, Storage::DataWrapper callerValue, DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); + caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, storage) .executeBody(parameterStorage); if (checkTrueishness(returnValue, storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, - callerValue.data._array->at(i).dataType, - callerValue.data._array->at(i).data); + caller.data._array->at(i).dataType, + caller.data._array->at(i).data); } } } @@ -749,22 +734,21 @@ Array::find(std::string method, Expr *caller, Storage::DataWrapper callerValue, } Storage::DataWrapper -Array::findIndex(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::findIndex(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::INTEGER, -1); } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::INTEGER, i); } } @@ -781,11 +765,11 @@ Array::findIndex(std::string method, Expr *caller, DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); + caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, storage) @@ -801,26 +785,25 @@ Array::findIndex(std::string method, Expr *caller, } Storage::DataWrapper -Array::findLast(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::findLast(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::_NULL, 0); } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { - for (int i = static_cast(callerValue.data._array->size()) - 1; i >= 0; + for (int i = static_cast(caller.data._array->size()) - 1; i >= 0; --i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, - callerValue.data._array->at(i).dataType, - callerValue.data._array->at(i).data); + caller.data._array->at(i).dataType, + caller.data._array->at(i).data); } } } else { @@ -836,20 +819,20 @@ Array::findLast(std::string method, Expr *caller, DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } - for (int i = static_cast(callerValue.data._array->size()) - 1; i >= 0; + for (int i = static_cast(caller.data._array->size()) - 1; i >= 0; --i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); + caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, storage) .executeBody(parameterStorage); if (checkTrueishness(returnValue, storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, - callerValue.data._array->at(i).dataType, - callerValue.data._array->at(i).data); + caller.data._array->at(i).dataType, + caller.data._array->at(i).data); } } } @@ -858,23 +841,22 @@ Array::findLast(std::string method, Expr *caller, } Storage::DataWrapper -Array::findLastIndex(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::findLastIndex(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::INTEGER, -1); } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { - for (int i = static_cast(callerValue.data._array->size()) - 1; i >= 0; + for (int i = static_cast(caller.data._array->size()) - 1; i >= 0; --i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::INTEGER, i); } } @@ -891,12 +873,12 @@ Array::findLastIndex(std::string method, Expr *caller, DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } - for (int i = static_cast(callerValue.data._array->size()) - 1; i >= 0; + for (int i = static_cast(caller.data._array->size()) - 1; i >= 0; --i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); + caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, storage) @@ -912,14 +894,13 @@ Array::findLastIndex(std::string method, Expr *caller, } Storage::DataWrapper -Array::filter(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::filter(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::ARRAY, new std::vector()); @@ -929,9 +910,9 @@ Array::filter(std::string method, Expr *caller, std::vector tmpElements = std::vector(); if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i)), storage)) { - tmpElements.push_back(callerValue.data._array->at(i)); + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { + if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { + tmpElements.push_back(caller.data._array->at(i)); } } } else { @@ -947,17 +928,17 @@ Array::filter(std::string method, Expr *caller, DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); + caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, storage) .executeBody(parameterStorage); if (checkTrueishness(returnValue, storage)) { - tmpElements.push_back(callerValue.data._array->at(i)); + tmpElements.push_back(caller.data._array->at(i)); } } } @@ -966,8 +947,7 @@ Array::filter(std::string method, Expr *caller, new std::vector(tmpElements)); } -Storage::DataWrapper Array::map(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Storage::DataWrapper Array::map(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { @@ -978,8 +958,8 @@ Storage::DataWrapper Array::map(std::string method, Expr *caller, std::vector tmpElements = std::vector(); if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { - tmpElements.push_back(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(callerValue.data._array->at(i))); + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { + tmpElements.push_back(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i))); } } else { if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { @@ -994,16 +974,16 @@ Storage::DataWrapper Array::map(std::string method, Expr *caller, DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::ARRAY, new std::vector()); } - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); + caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, storage) @@ -1017,8 +997,7 @@ Storage::DataWrapper Array::map(std::string method, Expr *caller, } Storage::DataWrapper -Array::reduce(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::reduce(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() < 1 || args.size() > 2) { @@ -1042,25 +1021,25 @@ Array::reduce(std::string method, Expr *caller, DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameters!"); } - if (callerValue.data._array->empty()) { + if (caller.data._array->empty()) { if (args.size() == 2) { return Expression(args[1].get(), storage).execute(); } throw std::logic_error("Invalid arguments!"); } - Storage::DataWrapper accumulator = callerValue.data._array->at(0); + Storage::DataWrapper accumulator = caller.data._array->at(0); if (args.size() == 2) { accumulator = Expression(args[1].get(), storage).execute(); } for (int i = args.size() == 2 ? 0 : 1; - i < static_cast(callerValue.data._array->size()); ++i) { + i < static_cast(caller.data._array->size()); ++i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, accumulator); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[1].value, - callerValue.data._array->at(i)); + caller.data._array->at(i)); accumulator = CallbackFunctionExpression( callbackFunction.data._callbackFunction, storage) .executeBody(parameterStorage); @@ -1069,7 +1048,7 @@ Array::reduce(std::string method, Expr *caller, } Storage::DataWrapper -Array::flat(std::string method, Expr *caller, Storage::DataWrapper callerValue, +Array::flat(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() > 1) { @@ -1083,12 +1062,11 @@ Array::flat(std::string method, Expr *caller, Storage::DataWrapper callerValue, int depth = args.size() == 1 ? Expression(args[0].get(), storage).execute().data._int : 1; - return flattenArray(callerValue, depth); + return flattenArray(caller, depth); } Storage::DataWrapper -Array::flatMap(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::flatMap(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { @@ -1110,11 +1088,11 @@ Array::flatMap(std::string method, Expr *caller, } std::vector tmpElements = std::vector(); - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); + caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, storage) @@ -1128,8 +1106,7 @@ Array::flatMap(std::string method, Expr *caller, } Storage::DataWrapper -Array::forEach(std::string method, Expr *caller, - Storage::DataWrapper callerValue, +Array::forEach(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage) { if (args.size() != 1) { @@ -1149,11 +1126,11 @@ Array::forEach(std::string method, Expr *caller, DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameters!"); } - for (int i = 0; i < static_cast(callerValue.data._array->size()); ++i) { + for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, - callerValue.data._array->at(i)); + caller.data._array->at(i)); CallbackFunctionExpression(callbackFunction.data._callbackFunction, storage) .executeBody(parameterStorage); } diff --git a/src/interpreter/expressions/binary_expression.cpp b/src/interpreter/expressions/binary_expression.cpp index 026b68d..240d7ae 100644 --- a/src/interpreter/expressions/binary_expression.cpp +++ b/src/interpreter/expressions/binary_expression.cpp @@ -379,7 +379,7 @@ Storage::DataWrapper BinaryExpression::stringAddition(std::string left, std::string right) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::STRING, - static_cast(new std::string(left + right))); + new std::string(left + right)); } Storage::DataWrapper BinaryExpression::stringMultiplication(std::string value, @@ -390,5 +390,5 @@ Storage::DataWrapper BinaryExpression::stringMultiplication(std::string value, } return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::STRING, - static_cast(new std::string(result))); + new std::string(result)); } diff --git a/src/interpreter/expressions/call_expression.cpp b/src/interpreter/expressions/call_expression.cpp index 0fd4519..c67b99c 100644 --- a/src/interpreter/expressions/call_expression.cpp +++ b/src/interpreter/expressions/call_expression.cpp @@ -70,10 +70,13 @@ Storage::DataWrapper CallExpression::methodCall() { expressionNode->caller.get(), std::move(expressionNode->args), storage); } else if (caller.dataType == Storage::DataType::ARRAY) { Array array; + std::string identifier = ""; + if (auto *identifierNode = dynamic_cast(expressionNode->caller.get())) { + identifier = identifierNode->identifier.value; + } return array.callMethod( - dynamic_cast(expressionNode->method.get()) - ->identifier.value, - expressionNode->caller.get(), std::move(expressionNode->args), storage); + dynamic_cast(expressionNode->method.get())->identifier.value, + Expression(expressionNode->caller.get(), storage).execute(), std::move(expressionNode->args), storage, identifier); } else { throw std::runtime_error("Invalid method call!"); } From f978a69eef99742c62264c1a96dcc27b8f116d17 Mon Sep 17 00:00:00 2001 From: marcelnoehre Date: Thu, 3 Apr 2025 22:21:03 +0200 Subject: [PATCH 8/9] fix chained call expressions --- src/interpreter/expressions/call_expression.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/interpreter/expressions/call_expression.cpp b/src/interpreter/expressions/call_expression.cpp index c67b99c..7be3b88 100644 --- a/src/interpreter/expressions/call_expression.cpp +++ b/src/interpreter/expressions/call_expression.cpp @@ -76,7 +76,7 @@ Storage::DataWrapper CallExpression::methodCall() { } return array.callMethod( dynamic_cast(expressionNode->method.get())->identifier.value, - Expression(expressionNode->caller.get(), storage).execute(), std::move(expressionNode->args), storage, identifier); + caller, std::move(expressionNode->args), storage, identifier); } else { throw std::runtime_error("Invalid method call!"); } From e5a6aaa599406266fa74d1523e3940941f24ee6f Mon Sep 17 00:00:00 2001 From: marcelnoehre Date: Thu, 3 Apr 2025 22:22:24 +0200 Subject: [PATCH 9/9] adjust code formatting --- include/interpreter/data/array.hpp | 36 ++- src/interpreter/data/array.cpp | 236 ++++++++++-------- .../expressions/call_expression.cpp | 6 +- .../short_operation_expression.cpp | 45 ++-- 4 files changed, 189 insertions(+), 134 deletions(-) diff --git a/include/interpreter/data/array.hpp b/include/interpreter/data/array.hpp index 9e5b147..6c8536b 100644 --- a/include/interpreter/data/array.hpp +++ b/include/interpreter/data/array.hpp @@ -43,10 +43,11 @@ enum class ArrayMethod { class Array { public: - Storage::DataWrapper - callMethod(std::string method, Storage::DataWrapper caller, - const std::vector> args, - std::vector> storage, std::string identifier); + Storage::DataWrapper callMethod(std::string method, + Storage::DataWrapper caller, + const std::vector> args, + std::vector> storage, + std::string identifier); private: inline static const std::unordered_map @@ -83,28 +84,36 @@ class Array { std::vector> storage); Storage::DataWrapper push(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier); + std::vector> storage, + std::string identifier); Storage::DataWrapper pop(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier); + std::vector> storage, + std::string identifier); Storage::DataWrapper shift(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier); + std::vector> storage, + std::string identifier); Storage::DataWrapper unshift(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier); + std::vector> storage, + std::string identifier); Storage::DataWrapper splice(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier); + std::vector> storage, + std::string identifier); Storage::DataWrapper reverse(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier); + std::vector> storage, + std::string identifier); Storage::DataWrapper sort(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier); + std::vector> storage, + std::string identifier); Storage::DataWrapper fill(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier); + std::vector> storage, + std::string identifier); Storage::DataWrapper concat(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); @@ -133,7 +142,8 @@ class Array { Storage::DataWrapper find(std::string method, Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); - Storage::DataWrapper findIndex(std::string method, Storage::DataWrapper caller, + Storage::DataWrapper findIndex(std::string method, + Storage::DataWrapper caller, const std::vector> &args, std::vector> storage); Storage::DataWrapper findLast(std::string method, Storage::DataWrapper caller, diff --git a/src/interpreter/data/array.cpp b/src/interpreter/data/array.cpp index da7e723..78731ae 100644 --- a/src/interpreter/data/array.cpp +++ b/src/interpreter/data/array.cpp @@ -3,7 +3,8 @@ Storage::DataWrapper Array::callMethod(std::string method, Storage::DataWrapper caller, const std::vector> args, - std::vector> storage, std::string identifier) { + std::vector> storage, + std::string identifier) { switch (stringToEnumMap.at(method)) { case ArrayMethod::LENGTH: return length(method, caller, args, storage); @@ -71,20 +72,20 @@ Array::length(std::string method, Storage::DataWrapper caller, if (args.size() != 0) { throw std::logic_error("Invalid number of arguments!"); } - return Storage::DataWrapper( - Storage::WrapperType::VALUE, Storage::DataType::INTEGER, - static_cast(caller.data._array->size())); + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::INTEGER, + static_cast(caller.data._array->size())); } -Storage::DataWrapper -Array::push(std::string method, Storage::DataWrapper caller, - const std::vector> &args, - std::vector> storage, std::string identifier) { +Storage::DataWrapper Array::push(std::string method, + Storage::DataWrapper caller, + const std::vector> &args, + std::vector> storage, + std::string identifier) { if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } - caller.data._array->push_back( - Expression(args[0].get(), storage).execute()); + caller.data._array->push_back(Expression(args[0].get(), storage).execute()); if (!identifier.empty()) { int keyIndex = storageKeyIndex(storage, identifier); if (keyIndex == -1) { @@ -92,14 +93,15 @@ Array::push(std::string method, Storage::DataWrapper caller, } storage[keyIndex]->updateValue(identifier, caller); } - return Storage::DataWrapper( - Storage::WrapperType::VALUE, Storage::DataType::INTEGER, - static_cast(caller.data._array->size())); + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::INTEGER, + static_cast(caller.data._array->size())); } Storage::DataWrapper Array::pop(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier) { + std::vector> storage, + std::string identifier) { Storage::DataWrapper tmpValue = Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::_NULL, 0); if (args.size() != 0) { @@ -123,7 +125,8 @@ Storage::DataWrapper Array::pop(std::string method, Storage::DataWrapper caller, Storage::DataWrapper Array::shift(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier) { + std::vector> storage, + std::string identifier) { Storage::DataWrapper tmpValue = Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::_NULL, 0); if (args.size() != 0) { @@ -144,14 +147,16 @@ Array::shift(std::string method, Storage::DataWrapper caller, return tmpValue; } -Storage::DataWrapper Array::unshift(std::string method, Storage::DataWrapper caller, +Storage::DataWrapper +Array::unshift(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier) { + std::vector> storage, + std::string identifier) { if (args.size() != 1) { throw std::logic_error("Invalid number of arguments!"); } caller.data._array->insert(caller.data._array->begin(), - Expression(args[0].get(), storage).execute()); + Expression(args[0].get(), storage).execute()); if (!identifier.empty()) { int keyIndex = storageKeyIndex(storage, identifier); if (keyIndex == -1) { @@ -159,14 +164,16 @@ Storage::DataWrapper Array::unshift(std::string method, Storage::DataWrapper cal } storage[keyIndex]->updateValue(identifier, caller); } - return Storage::DataWrapper( - Storage::WrapperType::VALUE, Storage::DataType::INTEGER, - static_cast(caller.data._array->size())); + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::INTEGER, + static_cast(caller.data._array->size())); } -Storage::DataWrapper Array::splice(std::string method, Storage::DataWrapper caller, +Storage::DataWrapper +Array::splice(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier) { + std::vector> storage, + std::string identifier) { Storage::DataWrapper tmpValue = Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::_NULL, 0); std::vector tmpElements, tmpDeletedElements; @@ -207,11 +214,10 @@ Storage::DataWrapper Array::splice(std::string method, Storage::DataWrapper call tmpDeletedElements.push_back(caller.data._array->at(start + i)); } caller.data._array->erase(caller.data._array->begin() + start, - caller.data._array->begin() + start + - count); + caller.data._array->begin() + start + count); for (int i = 0; i < static_cast(tmpElements.size()); ++i) { - caller.data._array->insert( - caller.data._array->begin() + start + i, tmpElements[i]); + caller.data._array->insert(caller.data._array->begin() + start + i, + tmpElements[i]); } if (!identifier.empty()) { int keyIndex = storageKeyIndex(storage, identifier); @@ -225,14 +231,15 @@ Storage::DataWrapper Array::splice(std::string method, Storage::DataWrapper call new std::vector(tmpDeletedElements)); } -Storage::DataWrapper Array::reverse(std::string method, Storage::DataWrapper caller, +Storage::DataWrapper +Array::reverse(std::string method, Storage::DataWrapper caller, const std::vector> &args, - std::vector> storage, std::string identifier) { + std::vector> storage, + std::string identifier) { if (args.size() != 0) { throw std::logic_error("Invalid number of arguments!"); } - std::reverse(caller.data._array->begin(), - caller.data._array->end()); + std::reverse(caller.data._array->begin(), caller.data._array->end()); if (!identifier.empty()) { int keyIndex = storageKeyIndex(storage, identifier); if (keyIndex == -1) { @@ -243,10 +250,11 @@ Storage::DataWrapper Array::reverse(std::string method, Storage::DataWrapper cal return caller; } -Storage::DataWrapper -Array::sort(std::string method, Storage::DataWrapper caller, - const std::vector> &args, - std::vector> storage, std::string identifier) { +Storage::DataWrapper Array::sort(std::string method, + Storage::DataWrapper caller, + const std::vector> &args, + std::vector> storage, + std::string identifier) { if (args.size() != 0) { throw std::logic_error("Invalid number of arguments!"); } @@ -290,10 +298,11 @@ Array::sort(std::string method, Storage::DataWrapper caller, return caller; } -Storage::DataWrapper -Array::fill(std::string method, Storage::DataWrapper caller, - const std::vector> &args, - std::vector> storage, std::string identifier) { +Storage::DataWrapper Array::fill(std::string method, + Storage::DataWrapper caller, + const std::vector> &args, + std::vector> storage, + std::string identifier) { Storage::DataWrapper tmpValue = Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::_NULL, 0); int start, end; @@ -340,8 +349,7 @@ Array::fill(std::string method, Storage::DataWrapper caller, end = Expression(args[2].get(), storage).execute().data._int; } for (int i = start; i < end; ++i) { - caller.data._array->at(i) = - Expression(args[0].get(), storage).execute(); + caller.data._array->at(i) = Expression(args[0].get(), storage).execute(); } if (!identifier.empty()) { int keyIndex = storageKeyIndex(storage, identifier); @@ -532,8 +540,7 @@ Array::lastIndexOf(std::string method, Storage::DataWrapper caller, Storage::DataType::_NULL) { throw std::logic_error("Invalid arguments!"); } - for (int i = static_cast(caller.data._array->size()) - 1; i >= 0; - --i) { + for (int i = static_cast(caller.data._array->size()) - 1; i >= 0; --i) { if (caller.data._array->at(i).equals( Expression(args[0].get(), storage).execute())) { return Storage::DataWrapper(Storage::WrapperType::VALUE, @@ -580,9 +587,13 @@ Array::every(std::string method, Storage::DataWrapper caller, } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + if (callbackFunction.dataType == + Storage::DataType::SHORT_NOTATION_OPERATION) { for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { - if (!checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { + if (!checkTrueishness(ShortOperationExpression( + callbackFunction.data._shortOperation, storage) + .executeExpression(caller.data._array->at(i)), + storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, false); } @@ -598,8 +609,8 @@ Array::every(std::string method, Storage::DataWrapper caller, } if (!(callbackFunction.data._callbackFunction->parameters[0].tag == Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { + callbackFunction.data._callbackFunction->parameters[0] + .type.dataToken == DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } if (caller.data._array->empty()) { @@ -613,7 +624,7 @@ Array::every(std::string method, Storage::DataWrapper caller, caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) + storage) .executeBody(parameterStorage); if (!checkTrueishness(returnValue, storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, @@ -621,7 +632,7 @@ Array::every(std::string method, Storage::DataWrapper caller, } } return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::BOOLEAN, true); + Storage::DataType::BOOLEAN, true); } } @@ -634,9 +645,13 @@ Array::some(std::string method, Storage::DataWrapper caller, } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + if (callbackFunction.dataType == + Storage::DataType::SHORT_NOTATION_OPERATION) { for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { + if (checkTrueishness(ShortOperationExpression( + callbackFunction.data._shortOperation, storage) + .executeExpression(caller.data._array->at(i)), + storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, true); } @@ -652,8 +667,8 @@ Array::some(std::string method, Storage::DataWrapper caller, } if (!(callbackFunction.data._callbackFunction->parameters[0].tag == Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { + callbackFunction.data._callbackFunction->parameters[0] + .type.dataToken == DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } if (caller.data._array->empty()) { @@ -667,7 +682,7 @@ Array::some(std::string method, Storage::DataWrapper caller, caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) + storage) .executeBody(parameterStorage); if (checkTrueishness(returnValue, storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, @@ -687,14 +702,18 @@ Array::find(std::string method, Storage::DataWrapper caller, throw std::logic_error("Invalid number of arguments!"); } if (caller.data._array->empty()) { - return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::_NULL, 0); + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::_NULL, 0); } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + if (callbackFunction.dataType == + Storage::DataType::SHORT_NOTATION_OPERATION) { for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { + if (checkTrueishness(ShortOperationExpression( + callbackFunction.data._shortOperation, storage) + .executeExpression(caller.data._array->at(i)), + storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, caller.data._array->at(i).dataType, caller.data._array->at(i).data); @@ -709,8 +728,8 @@ Array::find(std::string method, Storage::DataWrapper caller, } if (!(callbackFunction.data._callbackFunction->parameters[0].tag == Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { + callbackFunction.data._callbackFunction->parameters[0] + .type.dataToken == DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { @@ -720,7 +739,7 @@ Array::find(std::string method, Storage::DataWrapper caller, caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) + storage) .executeBody(parameterStorage); if (checkTrueishness(returnValue, storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, @@ -741,15 +760,20 @@ Array::findIndex(std::string method, Storage::DataWrapper caller, throw std::logic_error("Invalid number of arguments!"); } if (caller.data._array->empty()) { - return Storage::DataWrapper(Storage::WrapperType::VALUE, - Storage::DataType::INTEGER, -1); + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::INTEGER, -1); } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + if (callbackFunction.dataType == + Storage::DataType::SHORT_NOTATION_OPERATION) { for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { - return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::INTEGER, i); + if (checkTrueishness(ShortOperationExpression( + callbackFunction.data._shortOperation, storage) + .executeExpression(caller.data._array->at(i)), + storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::INTEGER, i); } } } else { @@ -761,8 +785,8 @@ Array::findIndex(std::string method, Storage::DataWrapper caller, } if (!(callbackFunction.data._callbackFunction->parameters[0].tag == Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { + callbackFunction.data._callbackFunction->parameters[0] + .type.dataToken == DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { @@ -772,7 +796,7 @@ Array::findIndex(std::string method, Storage::DataWrapper caller, caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) + storage) .executeBody(parameterStorage); if (checkTrueishness(returnValue, storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, @@ -797,10 +821,14 @@ Array::findLast(std::string method, Storage::DataWrapper caller, } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + if (callbackFunction.dataType == + Storage::DataType::SHORT_NOTATION_OPERATION) { for (int i = static_cast(caller.data._array->size()) - 1; i >= 0; - --i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { + --i) { + if (checkTrueishness(ShortOperationExpression( + callbackFunction.data._shortOperation, storage) + .executeExpression(caller.data._array->at(i)), + storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, caller.data._array->at(i).dataType, caller.data._array->at(i).data); @@ -815,19 +843,19 @@ Array::findLast(std::string method, Storage::DataWrapper caller, } if (!(callbackFunction.data._callbackFunction->parameters[0].tag == Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { + callbackFunction.data._callbackFunction->parameters[0] + .type.dataToken == DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } for (int i = static_cast(caller.data._array->size()) - 1; i >= 0; - --i) { + --i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) + storage) .executeBody(parameterStorage); if (checkTrueishness(returnValue, storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, @@ -853,11 +881,16 @@ Array::findLastIndex(std::string method, Storage::DataWrapper caller, } Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); - if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + if (callbackFunction.dataType == + Storage::DataType::SHORT_NOTATION_OPERATION) { for (int i = static_cast(caller.data._array->size()) - 1; i >= 0; - --i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { - return Storage::DataWrapper(Storage::WrapperType::VALUE, Storage::DataType::INTEGER, i); + --i) { + if (checkTrueishness(ShortOperationExpression( + callbackFunction.data._shortOperation, storage) + .executeExpression(caller.data._array->at(i)), + storage)) { + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::INTEGER, i); } } } else { @@ -869,19 +902,19 @@ Array::findLastIndex(std::string method, Storage::DataWrapper caller, } if (!(callbackFunction.data._callbackFunction->parameters[0].tag == Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { + callbackFunction.data._callbackFunction->parameters[0] + .type.dataToken == DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } for (int i = static_cast(caller.data._array->size()) - 1; i >= 0; - --i) { + --i) { std::shared_ptr parameterStorage = std::make_shared(); parameterStorage->setValue( callbackFunction.data._callbackFunction->parameters[0].value, caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) + storage) .executeBody(parameterStorage); if (checkTrueishness(returnValue, storage)) { return Storage::DataWrapper(Storage::WrapperType::VALUE, @@ -908,10 +941,14 @@ Array::filter(std::string method, Storage::DataWrapper caller, Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); std::vector tmpElements = - std::vector(); - if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + std::vector(); + if (callbackFunction.dataType == + Storage::DataType::SHORT_NOTATION_OPERATION) { for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { - if (checkTrueishness(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i)), storage)) { + if (checkTrueishness(ShortOperationExpression( + callbackFunction.data._shortOperation, storage) + .executeExpression(caller.data._array->at(i)), + storage)) { tmpElements.push_back(caller.data._array->at(i)); } } @@ -924,8 +961,8 @@ Array::filter(std::string method, Storage::DataWrapper caller, } if (!(callbackFunction.data._callbackFunction->parameters[0].tag == Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { + callbackFunction.data._callbackFunction->parameters[0] + .type.dataToken == DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { @@ -935,7 +972,7 @@ Array::filter(std::string method, Storage::DataWrapper caller, caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) + storage) .executeBody(parameterStorage); if (checkTrueishness(returnValue, storage)) { tmpElements.push_back(caller.data._array->at(i)); @@ -956,10 +993,13 @@ Storage::DataWrapper Array::map(std::string method, Storage::DataWrapper caller, Storage::DataWrapper callbackFunction = Expression(args[0].get(), storage).execute(); std::vector tmpElements = - std::vector(); - if (callbackFunction.dataType == Storage::DataType::SHORT_NOTATION_OPERATION) { + std::vector(); + if (callbackFunction.dataType == + Storage::DataType::SHORT_NOTATION_OPERATION) { for (int i = 0; i < static_cast(caller.data._array->size()); ++i) { - tmpElements.push_back(ShortOperationExpression(callbackFunction.data._shortOperation, storage).executeExpression(caller.data._array->at(i))); + tmpElements.push_back(ShortOperationExpression( + callbackFunction.data._shortOperation, storage) + .executeExpression(caller.data._array->at(i))); } } else { if (callbackFunction.dataType != Storage::DataType::CALLBACK_FUNCTION) { @@ -970,8 +1010,8 @@ Storage::DataWrapper Array::map(std::string method, Storage::DataWrapper caller, } if (!(callbackFunction.data._callbackFunction->parameters[0].tag == Token::TypeTag::DATA && - callbackFunction.data._callbackFunction->parameters[0].type.dataToken == - DataToken::IDENTIFIER)) { + callbackFunction.data._callbackFunction->parameters[0] + .type.dataToken == DataToken::IDENTIFIER)) { throw std::logic_error("Invalid parameter!"); } if (caller.data._array->empty()) { @@ -986,14 +1026,14 @@ Storage::DataWrapper Array::map(std::string method, Storage::DataWrapper caller, caller.data._array->at(i)); Storage::DataWrapper returnValue = CallbackFunctionExpression(callbackFunction.data._callbackFunction, - storage) + storage) .executeBody(parameterStorage); tmpElements.push_back(returnValue); } } return Storage::DataWrapper( - Storage::WrapperType::VALUE, Storage::DataType::ARRAY, - new std::vector(tmpElements)); + Storage::WrapperType::VALUE, Storage::DataType::ARRAY, + new std::vector(tmpElements)); } Storage::DataWrapper diff --git a/src/interpreter/expressions/call_expression.cpp b/src/interpreter/expressions/call_expression.cpp index 7be3b88..fc335ce 100644 --- a/src/interpreter/expressions/call_expression.cpp +++ b/src/interpreter/expressions/call_expression.cpp @@ -71,11 +71,13 @@ Storage::DataWrapper CallExpression::methodCall() { } else if (caller.dataType == Storage::DataType::ARRAY) { Array array; std::string identifier = ""; - if (auto *identifierNode = dynamic_cast(expressionNode->caller.get())) { + if (auto *identifierNode = + dynamic_cast(expressionNode->caller.get())) { identifier = identifierNode->identifier.value; } return array.callMethod( - dynamic_cast(expressionNode->method.get())->identifier.value, + dynamic_cast(expressionNode->method.get()) + ->identifier.value, caller, std::move(expressionNode->args), storage, identifier); } else { throw std::runtime_error("Invalid method call!"); diff --git a/src/interpreter/expressions/short_operation_expression.cpp b/src/interpreter/expressions/short_operation_expression.cpp index d2cdd6e..ae2704f 100644 --- a/src/interpreter/expressions/short_operation_expression.cpp +++ b/src/interpreter/expressions/short_operation_expression.cpp @@ -18,34 +18,36 @@ ShortOperationExpression::executeExpression(Storage::DataWrapper leftValue) { switch (expressionNode->operation.tag) { case Token::TypeTag::LOGICAL: if (expressionNode->operation.type.logicalToken == LogicalToken::GREATER) { - return Storage::DataWrapper( - Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, - checkGreater(leftValue, rightValue)); + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::BOOLEAN, + checkGreater(leftValue, rightValue)); } else if (expressionNode->operation.type.logicalToken == LogicalToken::LESS) { - return Storage::DataWrapper( - Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, - checkGreater(rightValue, leftValue)); + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::BOOLEAN, + checkGreater(rightValue, leftValue)); } else if (expressionNode->operation.type.logicalToken == LogicalToken::GREATER_EQUAL) { return Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, - checkGreater(leftValue, rightValue) || checkEquality(leftValue, rightValue, true)); + checkGreater(leftValue, rightValue) || + checkEquality(leftValue, rightValue, true)); } else if (expressionNode->operation.type.logicalToken == LogicalToken::LESS_EQUAL) { return Storage::DataWrapper( Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, - checkGreater(rightValue, leftValue) || checkEquality(leftValue, rightValue, true)); + checkGreater(rightValue, leftValue) || + checkEquality(leftValue, rightValue, true)); } else if (expressionNode->operation.type.logicalToken == LogicalToken::EQUAL) { - return Storage::DataWrapper( - Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, - checkEquality(leftValue, rightValue, true)); + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::BOOLEAN, + checkEquality(leftValue, rightValue, true)); } else if (expressionNode->operation.type.logicalToken == LogicalToken::NOT_EQUAL) { - return Storage::DataWrapper( - Storage::WrapperType::VALUE, Storage::DataType::BOOLEAN, - checkEquality(leftValue, rightValue, false)); + return Storage::DataWrapper(Storage::WrapperType::VALUE, + Storage::DataType::BOOLEAN, + checkEquality(leftValue, rightValue, false)); } else { throw std::invalid_argument("Invalid logical operation: " + expressionNode->operation.value); @@ -54,22 +56,22 @@ ShortOperationExpression::executeExpression(Storage::DataWrapper leftValue) { case Token::TypeTag::OPERATOR: if (expressionNode->operation.type.operatorToken == OperatorToken::ADDITION) { - return BinaryExpression::addition(leftValue, rightValue); + return BinaryExpression::addition(leftValue, rightValue); } else if (expressionNode->operation.type.operatorToken == OperatorToken::SUBTRACTION) { - return BinaryExpression::subtraction(leftValue, rightValue); + return BinaryExpression::subtraction(leftValue, rightValue); } else if (expressionNode->operation.type.operatorToken == OperatorToken::MULTIPLICATION) { - return BinaryExpression::multiplication(leftValue, rightValue); + return BinaryExpression::multiplication(leftValue, rightValue); } else if (expressionNode->operation.type.operatorToken == OperatorToken::DIVISION) { - return BinaryExpression::division(leftValue, rightValue); + return BinaryExpression::division(leftValue, rightValue); } else if (expressionNode->operation.type.operatorToken == OperatorToken::MODULUS) { - return BinaryExpression::modulus(leftValue, rightValue); + return BinaryExpression::modulus(leftValue, rightValue); } else if (expressionNode->operation.type.operatorToken == OperatorToken::POTENTIATION) { - return BinaryExpression::potentiation(leftValue, rightValue); + return BinaryExpression::potentiation(leftValue, rightValue); } else { throw std::invalid_argument("Invalid operator operation: " + expressionNode->operation.value); @@ -81,5 +83,6 @@ ShortOperationExpression::executeExpression(Storage::DataWrapper leftValue) { throw std::invalid_argument("Invalid short operation: " + expressionNode->operation.value); } - throw std::invalid_argument("Invalid short operation: " + expressionNode->operation.value); + throw std::invalid_argument("Invalid short operation: " + + expressionNode->operation.value); } \ No newline at end of file