From e2af5e519fc83935c8c3a6db93ae9e1844ae0a16 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Wed, 13 Dec 2023 09:41:20 -0500 Subject: [PATCH 01/55] 18652: Begins implementation of immediate return types for interpret node --- .../evaluablenode/EvaluableNodeManagement.h | 2 +- .../EvaluableNodeTreeFunctions.cpp | 4 +- .../EvaluableNodeTreeManipulation.cpp | 8 +- src/Amalgam/interpreter/Interpreter.cpp | 4 +- src/Amalgam/interpreter/Interpreter.h | 365 +++++++++--------- .../interpreter/InterpreterDebugger.cpp | 20 +- .../interpreter/InterpreterOpcodesBase.cpp | 72 ++-- .../InterpreterOpcodesCodeMixing.cpp | 34 +- .../InterpreterOpcodesDataTypes.cpp | 66 ++-- .../InterpreterOpcodesEntityAccess.cpp | 16 +- .../InterpreterOpcodesEntityControl.cpp | 30 +- .../InterpreterOpcodesListManipulation.cpp | 14 +- .../interpreter/InterpreterOpcodesLogic.cpp | 20 +- .../interpreter/InterpreterOpcodesMath.cpp | 70 ++-- .../InterpreterOpcodesTransformations.cpp | 34 +- 15 files changed, 382 insertions(+), 377 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index 02704937..33fad637 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -67,7 +67,7 @@ class EvaluableNodeReference } //allow to use as an EvaluableNode * - constexpr operator EvaluableNode *() + constexpr operator EvaluableNode *&() { return reference; } //allow to use as an EvaluableNode * diff --git a/src/Amalgam/evaluablenode/EvaluableNodeTreeFunctions.cpp b/src/Amalgam/evaluablenode/EvaluableNodeTreeFunctions.cpp index c509825b..17cc3f17 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeTreeFunctions.cpp +++ b/src/Amalgam/evaluablenode/EvaluableNodeTreeFunctions.cpp @@ -352,7 +352,7 @@ EvaluableNode **GetRelativeEvaluableNodeFromTraversalPathList(EvaluableNode **so EvaluableNodeReference AccumulateEvaluableNodeIntoEvaluableNode(EvaluableNodeReference value_destination_node, EvaluableNodeReference variable_value_node, EvaluableNodeManager *enm) { //if the destination is empty, then just use the value specified - if(value_destination_node.reference == nullptr) + if(value_destination_node == nullptr) return variable_value_node; //if the value is unique, then can just edit in place @@ -362,7 +362,7 @@ EvaluableNodeReference AccumulateEvaluableNodeIntoEvaluableNode(EvaluableNodeRef { double cur_value = EvaluableNode::ToNumber(value_destination_node); double inc_value = EvaluableNode::ToNumber(variable_value_node); - value_destination_node.reference->SetType(ENT_NUMBER, enm); + value_destination_node->SetType(ENT_NUMBER, enm); value_destination_node->SetNumberValue(cur_value + inc_value); } else if(value_destination_node->IsAssociativeArray()) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeTreeManipulation.cpp b/src/Amalgam/evaluablenode/EvaluableNodeTreeManipulation.cpp index c1bd92f6..706ab340 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeTreeManipulation.cpp +++ b/src/Amalgam/evaluablenode/EvaluableNodeTreeManipulation.cpp @@ -247,8 +247,8 @@ EvaluableNode *EvaluableNodeTreeManipulation::MixTreesByCommonLabels(Interpreter if(tree2 == nullptr) return result_tree; - auto index1 = RetrieveLabelIndexesFromTree(tree1.reference); - auto index2 = RetrieveLabelIndexesFromTree(tree2.reference); + auto index1 = RetrieveLabelIndexesFromTree(tree1); + auto index2 = RetrieveLabelIndexesFromTree(tree2); //normalize fraction to be less than 1 double total_fraction = fraction_a + fraction_b; @@ -281,7 +281,7 @@ EvaluableNode *EvaluableNodeTreeManipulation::MixTreesByCommonLabels(Interpreter all_labels.erase(begin(all_labels) + index_to_remove); //remove its label. Reuse enm for temporary since used it to create the new tree - ReplaceLabelInTree(result_tree.reference, label_id, nullptr); + ReplaceLabelInTree(result_tree, label_id, nullptr); } //replace labels from the second @@ -297,7 +297,7 @@ EvaluableNode *EvaluableNodeTreeManipulation::MixTreesByCommonLabels(Interpreter if(replacement_index != end(index2)) { EvaluableNode *replacement = enm->DeepAllocCopy(replacement_index->second); - ReplaceLabelInTree(result_tree.reference, label_id, replacement); + ReplaceLabelInTree(result_tree, label_id, replacement); } } diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index 4f5d7263..045907dc 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -475,7 +475,7 @@ EvaluableNode **Interpreter::GetOrCreateExecutionContextSymbolLocation(const Str return context_to_use->GetOrCreateMappedChildNode(symbol_sid); } -EvaluableNodeReference Interpreter::InterpretNode(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode(EvaluableNode *en, bool immediate_result) { if(EvaluableNode::IsNull(en)) return EvaluableNodeReference::Null(); @@ -515,7 +515,7 @@ EvaluableNodeReference Interpreter::InterpretNode(EvaluableNode *en) EvaluableNodeType ent = en->GetType(); auto oc = _opcodes[ent]; - EvaluableNodeReference retval = (this->*oc)(en); + EvaluableNodeReference retval = (this->*oc)(en, immediate_result); //for deep debugging only //ValidateEvaluableNodeIntegrity(); diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index 30dc3b1f..4411e542 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -145,7 +145,7 @@ class Interpreter stack_nodes[new_size + constructionStackOffsetTargetOrigin] = target_origin; stack_nodes[new_size + constructionStackOffsetTarget] = target; stack_nodes[new_size + constructionStackOffsetCurrentValue] = current_value; - stack_nodes[new_size + constructionStackOffsetPreviousResult] = previous_result.reference; + stack_nodes[new_size + constructionStackOffsetPreviousResult] = previous_result; stack_node_indices.emplace_back(current_index, previous_result.unique); } @@ -200,7 +200,7 @@ class Interpreter //assumes there is at least one construction stack entry __forceinline void SetTopPreviousResultInConstructionStack(EvaluableNodeReference previous_result) { - constructionStackNodes->at(constructionStackNodes->size() + constructionStackOffsetPreviousResult) = previous_result.reference; + constructionStackNodes->at(constructionStackNodes->size() + constructionStackOffsetPreviousResult) = previous_result; constructionStackIndicesAndUniqueness.back().unique = previous_result.unique; } @@ -268,7 +268,8 @@ class Interpreter } //keeps the current node on the stack and calls InterpretNodeExecution - EvaluableNodeReference InterpretNode(EvaluableNode *en); + //if immediate_result is true, it will not allocate a node + EvaluableNodeReference InterpretNode(EvaluableNode *en, bool immediate_result = false); //returns the number of steps executed since Interpreter was created constexpr ExecutionCycleCount GetNumStepsExecuted() @@ -610,245 +611,245 @@ class Interpreter //further, for performance, en must be guaranteed to be a valid pointer, and not nullptr //built-in / system specific - EvaluableNodeReference InterpretNode_ENT_SYSTEM(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_GET_DEFAULTS(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_SYSTEM(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_GET_DEFAULTS(EvaluableNode *en, bool immediate_result); //parsing - EvaluableNodeReference InterpretNode_ENT_PARSE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_UNPARSE(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_PARSE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_UNPARSE(EvaluableNode *en, bool immediate_result); //core control - EvaluableNodeReference InterpretNode_ENT_IF(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SEQUENCE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_PARALLEL(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_LAMBDA(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CONCLUDE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CALL(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CALL_SANDBOXED(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_WHILE(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_IF(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SEQUENCE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_PARALLEL(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_LAMBDA(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CONCLUDE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CALL(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CALL_SANDBOXED(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_WHILE(EvaluableNode *en, bool immediate_result); //definitions - EvaluableNodeReference InterpretNode_ENT_LET(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_DECLARE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ASSIGN_and_ACCUM(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_RETRIEVE(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_LET(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_DECLARE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ASSIGN_and_ACCUM(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_RETRIEVE(EvaluableNode *en, bool immediate_result); //base math - EvaluableNodeReference InterpretNode_ENT_ADD(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SUBTRACT(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_MULTIPLY(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_DIVIDE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_MODULUS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_GET_DIGITS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SET_DIGITS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_FLOOR(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CEILING(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ROUND(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_ADD(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SUBTRACT(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_MULTIPLY(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_DIVIDE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_MODULUS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_GET_DIGITS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SET_DIGITS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_FLOOR(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CEILING(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ROUND(EvaluableNode *en, bool immediate_result); //extended math - EvaluableNodeReference InterpretNode_ENT_EXPONENT(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_LOG(EvaluableNode *en); - - EvaluableNodeReference InterpretNode_ENT_SIN(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ASIN(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_COS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ACOS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_TAN(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ATAN(EvaluableNode *en); - - EvaluableNodeReference InterpretNode_ENT_SINH(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ASINH(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_COSH(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ACOSH(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_TANH(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ATANH(EvaluableNode *en); - - EvaluableNodeReference InterpretNode_ENT_ERF(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_TGAMMA(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_LGAMMA(EvaluableNode *en); - - EvaluableNodeReference InterpretNode_ENT_SQRT(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_POW(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ABS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_MAX(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_MIN(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_DOT_PRODUCT(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_GENERALIZED_DISTANCE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ENTROPY(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_EXPONENT(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_LOG(EvaluableNode *en, bool immediate_result); + + EvaluableNodeReference InterpretNode_ENT_SIN(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ASIN(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_COS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ACOS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_TAN(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ATAN(EvaluableNode *en, bool immediate_result); + + EvaluableNodeReference InterpretNode_ENT_SINH(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ASINH(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_COSH(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ACOSH(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_TANH(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ATANH(EvaluableNode *en, bool immediate_result); + + EvaluableNodeReference InterpretNode_ENT_ERF(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_TGAMMA(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_LGAMMA(EvaluableNode *en, bool immediate_result); + + EvaluableNodeReference InterpretNode_ENT_SQRT(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_POW(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ABS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_MAX(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_MIN(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_DOT_PRODUCT(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_GENERALIZED_DISTANCE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ENTROPY(EvaluableNode *en, bool immediate_result); //list manipulation - EvaluableNodeReference InterpretNode_ENT_FIRST(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_TAIL(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_LAST(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_TRUNC(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_APPEND(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SIZE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_RANGE(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_FIRST(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_TAIL(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_LAST(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_TRUNC(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_APPEND(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SIZE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_RANGE(EvaluableNode *en, bool immediate_result); //transformation - EvaluableNodeReference InterpretNode_ENT_REWRITE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_MAP(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_FILTER(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_WEAVE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_REDUCE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_APPLY(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_REVERSE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SORT(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_REWRITE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_MAP(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_FILTER(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_WEAVE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_REDUCE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_APPLY(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_REVERSE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SORT(EvaluableNode *en, bool immediate_result); //associative list manipulation - EvaluableNodeReference InterpretNode_ENT_INDICES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_VALUES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CONTAINS_INDEX(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CONTAINS_VALUE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_REMOVE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_KEEP(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ASSOCIATE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ZIP(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_UNZIP(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_INDICES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_VALUES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CONTAINS_INDEX(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CONTAINS_VALUE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_REMOVE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_KEEP(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ASSOCIATE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ZIP(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_UNZIP(EvaluableNode *en, bool immediate_result); //retrieval - EvaluableNodeReference InterpretNode_ENT_GET(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SET_and_REPLACE(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_GET(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SET_and_REPLACE(EvaluableNode *en, bool immediate_result); //stack and node manipulation - EvaluableNodeReference InterpretNode_ENT_TARGET(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CURRENT_INDEX(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CURRENT_VALUE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_PREVIOUS_RESULT(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_STACK(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ARGS(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_TARGET(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CURRENT_INDEX(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CURRENT_VALUE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_PREVIOUS_RESULT(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_STACK(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ARGS(EvaluableNode *en, bool immediate_result); //logic - EvaluableNodeReference InterpretNode_ENT_AND(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_OR(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_XOR(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_NOT(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_AND(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_OR(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_XOR(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_NOT(EvaluableNode *en, bool immediate_result); //equivalence - EvaluableNodeReference InterpretNode_ENT_EQUAL(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_NEQUAL(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_LESS_and_LEQUAL(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_GREATER_and_GEQUAL(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_TYPE_EQUALS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_TYPE_NEQUALS(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_EQUAL(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_NEQUAL(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_LESS_and_LEQUAL(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_GREATER_and_GEQUAL(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_TYPE_EQUALS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_TYPE_NEQUALS(EvaluableNode *en, bool immediate_result); //simulation and operations - EvaluableNodeReference InterpretNode_ENT_RAND(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_WEIGHTED_RAND(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_GET_RAND_SEED(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SET_RAND_SEED(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SYSTEM_TIME(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_RAND(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_WEIGHTED_RAND(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_GET_RAND_SEED(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SET_RAND_SEED(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SYSTEM_TIME(EvaluableNode *en, bool immediate_result); //built-in constants and variables - EvaluableNodeReference InterpretNode_ENT_TRUE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_FALSE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_NULL(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_TRUE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_FALSE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_NULL(EvaluableNode *en, bool immediate_result); //data types - EvaluableNodeReference InterpretNode_ENT_LIST(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ASSOC(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_NUMBER(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_STRING(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SYMBOL(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_LIST(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ASSOC(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_NUMBER(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_STRING(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SYMBOL(EvaluableNode *en, bool immediate_result); //node types - EvaluableNodeReference InterpretNode_ENT_GET_TYPE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_GET_TYPE_STRING(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SET_TYPE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_FORMAT(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_GET_TYPE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_GET_TYPE_STRING(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SET_TYPE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_FORMAT(EvaluableNode *en, bool immediate_result); //EvaluableNode management: labels, comments, and concurrency - EvaluableNodeReference InterpretNode_ENT_GET_LABELS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_GET_ALL_LABELS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SET_LABELS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ZIP_LABELS(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_GET_LABELS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_GET_ALL_LABELS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SET_LABELS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ZIP_LABELS(EvaluableNode *en, bool immediate_result); - EvaluableNodeReference InterpretNode_ENT_GET_COMMENTS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SET_COMMENTS(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_GET_COMMENTS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SET_COMMENTS(EvaluableNode *en, bool immediate_result); - EvaluableNodeReference InterpretNode_ENT_GET_CONCURRENCY(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SET_CONCURRENCY(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_GET_CONCURRENCY(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SET_CONCURRENCY(EvaluableNode *en, bool immediate_result); - EvaluableNodeReference InterpretNode_ENT_GET_VALUE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SET_VALUE(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_GET_VALUE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SET_VALUE(EvaluableNode *en, bool immediate_result); //string - EvaluableNodeReference InterpretNode_ENT_EXPLODE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SPLIT(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SUBSTR(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CONCAT(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_EXPLODE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SPLIT(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SUBSTR(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CONCAT(EvaluableNode *en, bool immediate_result); //encryption - EvaluableNodeReference InterpretNode_ENT_CRYPTO_SIGN(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CRYPTO_SIGN_VERIFY(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ENCRYPT(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_DECRYPT(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_CRYPTO_SIGN(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CRYPTO_SIGN_VERIFY(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ENCRYPT(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_DECRYPT(EvaluableNode *en, bool immediate_result); //I/O - EvaluableNodeReference InterpretNode_ENT_PRINT(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_PRINT(EvaluableNode *en, bool immediate_result); //tree merging - EvaluableNodeReference InterpretNode_ENT_TOTAL_SIZE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_MUTATE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_COMMONALITY(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_EDIT_DISTANCE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_INTERSECT(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_UNION(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_DIFFERENCE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_MIX(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_MIX_LABELS(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_TOTAL_SIZE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_MUTATE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_COMMONALITY(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_EDIT_DISTANCE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_INTERSECT(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_UNION(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_DIFFERENCE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_MIX(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_MIX_LABELS(EvaluableNode *en, bool immediate_result); //entity merging - EvaluableNodeReference InterpretNode_ENT_TOTAL_ENTITY_SIZE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_FLATTEN_ENTITY(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_MUTATE_ENTITY(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_COMMONALITY_ENTITIES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_EDIT_DISTANCE_ENTITIES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_INTERSECT_ENTITIES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_UNION_ENTITIES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_DIFFERENCE_ENTITIES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_MIX_ENTITIES(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_TOTAL_ENTITY_SIZE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_FLATTEN_ENTITY(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_MUTATE_ENTITY(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_COMMONALITY_ENTITIES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_EDIT_DISTANCE_ENTITIES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_INTERSECT_ENTITIES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_UNION_ENTITIES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_DIFFERENCE_ENTITIES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_MIX_ENTITIES(EvaluableNode *en, bool immediate_result); //entity details - EvaluableNodeReference InterpretNode_ENT_GET_ENTITY_COMMENTS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_RETRIEVE_ENTITY_ROOT(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ASSIGN_ENTITY_ROOTS_and_ACCUM_ENTITY_ROOTS(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_GET_ENTITY_RAND_SEED(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SET_ENTITY_RAND_SEED(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_GET_ENTITY_ROOT_PERMISSION(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_SET_ENTITY_ROOT_PERMISSION(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_GET_ENTITY_COMMENTS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_RETRIEVE_ENTITY_ROOT(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ASSIGN_ENTITY_ROOTS_and_ACCUM_ENTITY_ROOTS(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_GET_ENTITY_RAND_SEED(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SET_ENTITY_RAND_SEED(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_GET_ENTITY_ROOT_PERMISSION(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_SET_ENTITY_ROOT_PERMISSION(EvaluableNode *en, bool immediate_result); //entity base actions - EvaluableNodeReference InterpretNode_ENT_CREATE_ENTITIES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CLONE_ENTITIES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_MOVE_ENTITIES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_DESTROY_ENTITIES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_LOAD(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_LOAD_ENTITY_and_LOAD_PERSISTENT_ENTITY(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_STORE(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_STORE_ENTITY(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CONTAINS_ENTITY(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_CREATE_ENTITIES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CLONE_ENTITIES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_MOVE_ENTITIES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_DESTROY_ENTITIES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_LOAD(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_LOAD_ENTITY_and_LOAD_PERSISTENT_ENTITY(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_STORE(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_STORE_ENTITY(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CONTAINS_ENTITY(EvaluableNode *en, bool immediate_result); //entity query - EvaluableNodeReference InterpretNode_ENT_CONTAINED_ENTITIES_and_COMPUTE_ON_CONTAINED_ENTITIES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_QUERY_and_COMPUTE_opcodes(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_CONTAINED_ENTITIES_and_COMPUTE_ON_CONTAINED_ENTITIES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_QUERY_and_COMPUTE_opcodes(EvaluableNode *en, bool immediate_result); //entity access - EvaluableNodeReference InterpretNode_ENT_CONTAINS_LABEL(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_ASSIGN_TO_ENTITIES_and_DIRECT_ASSIGN_TO_ENTITIES_and_ACCUM_TO_ENTITIES(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_CONTAINS_LABEL(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_ASSIGN_TO_ENTITIES_and_DIRECT_ASSIGN_TO_ENTITIES_and_ACCUM_TO_ENTITIES(EvaluableNode *en, bool immediate_result); - EvaluableNodeReference InterpretNode_ENT_RETRIEVE_FROM_ENTITY_and_DIRECT_RETRIEVE_FROM_ENTITY(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CALL_ENTITY_and_CALL_ENTITY_GET_CHANGES(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_CALL_CONTAINER(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_RETRIEVE_FROM_ENTITY_and_DIRECT_RETRIEVE_FROM_ENTITY(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CALL_ENTITY_and_CALL_ENTITY_GET_CHANGES(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_CALL_CONTAINER(EvaluableNode *en, bool immediate_result); - EvaluableNodeReference InterpretNode_ENT_DEALLOCATED(EvaluableNode *en); - EvaluableNodeReference InterpretNode_ENT_NOT_A_BUILT_IN_TYPE(EvaluableNode *en); + EvaluableNodeReference InterpretNode_ENT_DEALLOCATED(EvaluableNode *en, bool immediate_result); + EvaluableNodeReference InterpretNode_ENT_NOT_A_BUILT_IN_TYPE(EvaluableNode *en, bool immediate_result); //override hook for debugging - EvaluableNodeReference InterpretNode_DEBUG(EvaluableNode *en); + EvaluableNodeReference InterpretNode_DEBUG(EvaluableNode *en, bool immediate_result); //override hook for profiling - EvaluableNodeReference InterpretNode_PROFILE(EvaluableNode *en); + EvaluableNodeReference InterpretNode_PROFILE(EvaluableNode *en, bool immediate_result); //ensures that there are no reachable nodes that are deallocated void ValidateEvaluableNodeIntegrity(); @@ -919,7 +920,7 @@ class Interpreter //opcode function pointers // each opcode function takes in an EvaluableNode - typedef EvaluableNodeReference(Interpreter::*OpcodeFunction) (EvaluableNode *); + typedef EvaluableNodeReference(Interpreter::*OpcodeFunction) (EvaluableNode *, bool); static std::array _opcodes; //opcodes that all point to debugging diff --git a/src/Amalgam/interpreter/InterpreterDebugger.cpp b/src/Amalgam/interpreter/InterpreterDebugger.cpp index 6385ca69..bcb8dd67 100644 --- a/src/Amalgam/interpreter/InterpreterDebugger.cpp +++ b/src/Amalgam/interpreter/InterpreterDebugger.cpp @@ -140,7 +140,7 @@ void PrintStackNode(EvaluableNode *en, EvaluableNodeManager *enm, size_t max_num } } -EvaluableNodeReference Interpreter::InterpretNode_DEBUG(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_DEBUG(EvaluableNode *en, bool immediate_result) { DebugCheckBreakpointsAndUpdateState(en, true); @@ -165,9 +165,10 @@ EvaluableNodeReference Interpreter::InterpretNode_DEBUG(EvaluableNode *en) if(!enter_interactive_mode) { - //get corresponding opcode stored in _debug_opcodes + //get corresponding opcode stored in _debug_opcodes, + //but don't ever request immediate when debugging auto oc = _debug_opcodes[cur_node_type]; - EvaluableNodeReference retval = (this->*oc)(en); + EvaluableNodeReference retval = (this->*oc)(en, false); //check for debug after execution DebugCheckBreakpointsAndUpdateState(en, false); @@ -186,8 +187,9 @@ EvaluableNodeReference Interpreter::InterpretNode_DEBUG(EvaluableNode *en) lock.unlock(); //get corresponding opcode stored in _debug_opcodes + //don't request immediate when debugging auto oc = _debug_opcodes[cur_node_type]; - EvaluableNodeReference retval = (this->*oc)(en); + EvaluableNodeReference retval = (this->*oc)(en, false); //check for debug after execution DebugCheckBreakpointsAndUpdateState(en, false); @@ -341,7 +343,8 @@ EvaluableNodeReference Interpreter::InterpretNode_DEBUG(EvaluableNode *en) lock.unlock(); #endif - EvaluableNodeReference retval = (this->*oc)(en); + //don't request immediate when debugging + EvaluableNodeReference retval = (this->*oc)(en, false); return retval; } else if(command == "bl") @@ -559,8 +562,9 @@ EvaluableNodeReference Interpreter::InterpretNode_DEBUG(EvaluableNode *en) #endif //get corresponding opcode stored in _debug_opcodes + //don't request immediate when debugging auto oc = _debug_opcodes[en->GetType()]; - EvaluableNodeReference retval = (this->*oc)(en); + EvaluableNodeReference retval = (this->*oc)(en, false); //check for debug after execution DebugCheckBreakpointsAndUpdateState(en, false); @@ -786,7 +790,7 @@ void Interpreter::DebugCheckBreakpointsAndUpdateState(EvaluableNode *en, bool be } } -EvaluableNodeReference Interpreter::InterpretNode_PROFILE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_PROFILE(EvaluableNode *en, bool immediate_result) { std::string opcode_str; @@ -819,7 +823,7 @@ EvaluableNodeReference Interpreter::InterpretNode_PROFILE(EvaluableNode *en) //get corresponding opcode stored in _profile_opcodes auto oc = _profile_opcodes[cur_node_type]; - EvaluableNodeReference retval = (this->*oc)(en); + EvaluableNodeReference retval = (this->*oc)(en, immediate_result); PerformanceProfiler::EndOperation(evaluableNodeManager->GetNumberOfUsedNodes()); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp index 2a2d8adb..41c17b9c 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp @@ -57,7 +57,7 @@ std::string GetEntityMemorySizeDiagnostics(Entity *e) return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() == 0) @@ -214,7 +214,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM(EvaluableNode *en) return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_DEFAULTS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_DEFAULTS(EvaluableNode *en, bool immediate_result) { if(en->GetOrderedChildNodes().size() == 0) return EvaluableNodeReference::Null(); @@ -254,7 +254,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_DEFAULTS(EvaluableNode return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_PARSE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_PARSE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() == 0) @@ -267,7 +267,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_PARSE(EvaluableNode *en) return Parser::Parse(to_parse, evaluableNodeManager); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_UNPARSE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_UNPARSE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() == 0) @@ -289,7 +289,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_UNPARSE(EvaluableNode *en) return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_IF(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_IF(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); size_t num_cn = ocn.size(); @@ -321,7 +321,7 @@ inline EvaluableNodeReference RemoveConcludeFromConclusion(EvaluableNodeReferenc return EvaluableNodeReference(conclusion, result.unique); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SEQUENCE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SEQUENCE(EvaluableNode *en, bool immediate_result) { EvaluableNodeReference result = EvaluableNodeReference::Null(); for(auto &cn : en->GetOrderedChildNodes()) @@ -335,7 +335,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SEQUENCE(EvaluableNode *en return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_PARALLEL(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_PARALLEL(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -395,7 +395,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_PARALLEL(EvaluableNode *en return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_LAMBDA(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_LAMBDA(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); size_t ocn_size = ocn.size(); @@ -421,7 +421,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LAMBDA(EvaluableNode *en) } } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CONCLUDE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CONCLUDE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -443,7 +443,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONCLUDE(EvaluableNode *en return conclusion; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -478,7 +478,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL(EvaluableNode *en) return retval; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL_SANDBOXED(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL_SANDBOXED(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -571,7 +571,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL_SANDBOXED(EvaluableNo return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_WHILE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_WHILE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -634,7 +634,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_WHILE(EvaluableNode *en) return previous_result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_LET(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_LET(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -666,7 +666,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LET(EvaluableNode *en) return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_DECLARE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_DECLARE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -752,7 +752,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DECLARE(EvaluableNode *en) return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_and_ACCUM(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_and_ACCUM(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); size_t num_params = ocn.size(); @@ -855,7 +855,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_and_ACCUM(Evaluable } //assign back into the context_to_use - *value_destination = variable_value_node.reference; + *value_destination = variable_value_node; } return EvaluableNodeReference::Null(); @@ -911,7 +911,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_and_ACCUM(Evaluable EvaluableNodeReference variable_value_node = AccumulateEvaluableNodeIntoEvaluableNode(value_destination_node, new_value, evaluableNodeManager); //assign the new accumulation - *value_destination = variable_value_node.reference; + *value_destination = variable_value_node; } else { @@ -976,7 +976,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_and_ACCUM(Evaluable EvaluableNodeReference variable_value_node = AccumulateEvaluableNodeIntoEvaluableNode(value_destination_node, new_value, evaluableNodeManager); //assign the new accumulation - *copy_destination = variable_value_node.reference; + *copy_destination = variable_value_node; } else { @@ -991,7 +991,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_and_ACCUM(Evaluable return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1023,7 +1023,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE(EvaluableNode *en cn = GetExecutionContextSymbol(cn_id); } - return EvaluableNodeReference(to_lookup.reference, false); + return EvaluableNodeReference(to_lookup, false); } else //ordered params { @@ -1048,11 +1048,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE(EvaluableNode *en cn = GetExecutionContextSymbol(symbol_name_sid); } - return EvaluableNodeReference(to_lookup.reference, false); + return EvaluableNodeReference(to_lookup, false); } } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); size_t ocn_size = ocn.size(); @@ -1104,7 +1104,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET(EvaluableNode *en) return retrieved_list; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_and_REPLACE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_and_REPLACE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1200,7 +1200,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_and_REPLACE(EvaluableN return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_TARGET(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_TARGET(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1222,7 +1222,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TARGET(EvaluableNode *en) return EvaluableNodeReference(constructionStackNodes->at(offset), false); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_INDEX(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_INDEX(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1254,7 +1254,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_INDEX(EvaluableNod return EvaluableNodeReference(index_node, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_VALUE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_VALUE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1276,7 +1276,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_VALUE(EvaluableNod return EvaluableNodeReference(constructionStackNodes->at(offset), false); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_PREVIOUS_RESULT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_PREVIOUS_RESULT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1297,7 +1297,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_PREVIOUS_RESULT(EvaluableN return GetAndClearPreviousResultInConstructionStack(depth); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_STACK(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_STACK(EvaluableNode *en, bool immediate_result) { #ifdef MULTITHREAD_SUPPORT //accessing everything in the stack, so need exclusive access @@ -1319,7 +1319,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_STACK(EvaluableNode *en) return evaluableNodeManager->DeepAllocCopy(&stack_top_holder); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ARGS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ARGS(EvaluableNode *en, bool immediate_result) { size_t depth = 0; auto &ocn = en->GetOrderedChildNodes(); @@ -1360,7 +1360,7 @@ EvaluableNodeReference GenerateRandomValueBasedOnRandParam(EvaluableNodeReferenc return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_RAND(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_RAND(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1656,7 +1656,7 @@ EvaluableNodeReference GenerateWeightedRandomValueBasedOnRandParam(EvaluableNode return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_WEIGHTED_RAND(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_WEIGHTED_RAND(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1836,13 +1836,13 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_WEIGHTED_RAND(EvaluableNod return retval; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_RAND_SEED(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_RAND_SEED(EvaluableNode *en, bool immediate_result) { std::string rand_state_string = randomStream.GetState(); return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, rand_state_string), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_RAND_SEED(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_RAND_SEED(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1861,7 +1861,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_RAND_SEED(EvaluableNod return seed_node; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM_TIME(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM_TIME(EvaluableNode *en, bool immediate_result) { if(!asset_manager.DoesEntityHaveRootPermission(curEntity)) return EvaluableNodeReference::Null(); @@ -1876,13 +1876,13 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM_TIME(EvaluableNode //error handling -EvaluableNodeReference Interpreter::InterpretNode_ENT_DEALLOCATED(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_DEALLOCATED(EvaluableNode *en, bool immediate_result) { std::cout << "ERROR: attempt to use freed memory\n"; return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_NOT_A_BUILT_IN_TYPE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_NOT_A_BUILT_IN_TYPE(EvaluableNode *en, bool immediate_result) { std::cout << "ERROR: encountered an invalid instruction\n"; return EvaluableNodeReference::Null(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp b/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp index 6055b679..fbe94c64 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp @@ -19,7 +19,7 @@ #include #include -EvaluableNodeReference Interpreter::InterpretNode_ENT_MUTATE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_MUTATE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -71,7 +71,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MUTATE(EvaluableNode *en) return EvaluableNodeReference(result, false); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_COMMONALITY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_COMMONALITY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -107,7 +107,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COMMONALITY(EvaluableNode return EvaluableNodeReference(evaluableNodeManager->AllocNode(results.commonality), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_EDIT_DISTANCE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_EDIT_DISTANCE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -145,7 +145,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EDIT_DISTANCE(EvaluableNod return EvaluableNodeReference(evaluableNodeManager->AllocNode(edit_distance), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_INTERSECT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_INTERSECT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -168,7 +168,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_INTERSECT(EvaluableNode *e return EvaluableNodeReference(result, (n1.unique && n2.unique)); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_UNION(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_UNION(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -191,7 +191,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_UNION(EvaluableNode *en) return EvaluableNodeReference(result, (n1.unique && n2.unique)); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_DIFFERENCE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_DIFFERENCE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -214,7 +214,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DIFFERENCE(EvaluableNode * return EvaluableNodeReference(result, (n1.unique && n2.unique)); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_MIX(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_MIX(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -254,7 +254,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MIX(EvaluableNode *en) return EvaluableNodeReference(result, (n1.unique && n2.unique)); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_MIX_LABELS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_MIX_LABELS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -289,7 +289,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MIX_LABELS(EvaluableNode * return EvaluableNodeReference(result, (n1.unique && n2.unique)); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_TOTAL_ENTITY_SIZE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_TOTAL_ENTITY_SIZE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -306,7 +306,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TOTAL_ENTITY_SIZE(Evaluabl return EvaluableNodeReference(evaluableNodeManager->AllocNode(size), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_FLATTEN_ENTITY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_FLATTEN_ENTITY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -330,7 +330,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FLATTEN_ENTITY(EvaluableNo return EntityManipulation::FlattenEntity(this, source_entity, include_rand_seeds, parallel_create); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_MUTATE_ENTITY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_MUTATE_ENTITY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -412,7 +412,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MUTATE_ENTITY(EvaluableNod return EvaluableNodeReference(GetTraversalIDPathFromAToB(evaluableNodeManager, curEntity, new_entity), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_COMMONALITY_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_COMMONALITY_ENTITIES(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -434,7 +434,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COMMONALITY_ENTITIES(Evalu return EvaluableNodeReference(evaluableNodeManager->AllocNode(commonality.commonality), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_EDIT_DISTANCE_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_EDIT_DISTANCE_ENTITIES(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -456,7 +456,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EDIT_DISTANCE_ENTITIES(Eva return EvaluableNodeReference(evaluableNodeManager->AllocNode(edit_distance), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_INTERSECT_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_INTERSECT_ENTITIES(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -509,7 +509,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_INTERSECT_ENTITIES(Evaluab return EvaluableNodeReference(GetTraversalIDPathFromAToB(evaluableNodeManager, curEntity, new_entity), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_UNION_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_UNION_ENTITIES(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -562,7 +562,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_UNION_ENTITIES(EvaluableNo return EvaluableNodeReference(GetTraversalIDPathFromAToB(evaluableNodeManager, curEntity, new_entity), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_DIFFERENCE_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_DIFFERENCE_ENTITIES(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -585,7 +585,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DIFFERENCE_ENTITIES(Evalua return EntityManipulation::DifferenceEntities(this, entity_1, entity_2); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_MIX_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_MIX_ENTITIES(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index 29964a19..a1e1b61c 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -26,22 +26,22 @@ #include #include -EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUE(EvaluableNode *en, bool immediate_result) { return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_FALSE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_FALSE(EvaluableNode *en, bool immediate_result) { return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_NULL(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_NULL(EvaluableNode *en, bool immediate_result) { return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_LIST(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_LIST(EvaluableNode *en, bool immediate_result) { //if idempotent, can just return a copy without any metadata if(en->GetIsIdempotent()) @@ -105,7 +105,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LIST(EvaluableNode *en) return new_list; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSOC(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSOC(EvaluableNode *en, bool immediate_result) { //if idempotent, can just return a copy without any metadata if(en->GetIsIdempotent()) @@ -178,17 +178,17 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSOC(EvaluableNode *en) return new_assoc; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_NUMBER(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_NUMBER(EvaluableNode *en, bool immediate_result) { return EvaluableNodeReference(evaluableNodeManager->AllocNode(en->GetNumberValueReference()), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_STRING(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_STRING(EvaluableNode *en, bool immediate_result) { return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, en->GetStringIDReference()), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SYMBOL(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SYMBOL(EvaluableNode *en, bool immediate_result) { StringInternPool::StringID sid = EvaluableNode::ToStringIDIfExists(en); if(sid == StringInternPool::NOT_A_STRING_ID) @@ -206,7 +206,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYMBOL(EvaluableNode *en) return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -222,7 +222,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE(EvaluableNode *en return EvaluableNodeReference(evaluableNodeManager->AllocNode(type), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE_STRING(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE_STRING(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -239,7 +239,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE_STRING(EvaluableN return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, type_string), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_TYPE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_TYPE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -286,7 +286,7 @@ constexpr DestinationType ExpandCharStorage(char &value) return static_cast(reinterpret_cast(value)); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_FORMAT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_FORMAT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -886,7 +886,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FORMAT(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, string_value), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_LABELS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_LABELS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -912,7 +912,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_LABELS(EvaluableNode * return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ALL_LABELS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ALL_LABELS(EvaluableNode *en, bool immediate_result) { EvaluableNodeReference n = EvaluableNodeReference::Null(); @@ -922,7 +922,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ALL_LABELS(EvaluableNo EvaluableNodeReference result(evaluableNodeManager->AllocNode(ENT_ASSOC), n.unique); - auto label_sids_to_nodes = EvaluableNodeTreeManipulation::RetrieveLabelIndexesFromTree(n.reference); + auto label_sids_to_nodes = EvaluableNodeTreeManipulation::RetrieveLabelIndexesFromTree(n); string_intern_pool.CreateStringReferences(label_sids_to_nodes, [](auto it) { return it.first; }); result->ReserveMappedChildNodes(label_sids_to_nodes.size()); @@ -936,7 +936,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ALL_LABELS(EvaluableNo return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_LABELS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_LABELS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -979,7 +979,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_LABELS(EvaluableNode * return source; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ZIP_LABELS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ZIP_LABELS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1057,7 +1057,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ZIP_LABELS(EvaluableNode * return retval; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_COMMENTS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_COMMENTS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1077,7 +1077,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_COMMENTS(EvaluableNode return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, comments_sid), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_COMMENTS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_COMMENTS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1099,7 +1099,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_COMMENTS(EvaluableNode return source; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_CONCURRENCY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_CONCURRENCY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1112,7 +1112,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_CONCURRENCY(EvaluableN return EvaluableNodeReference(evaluableNodeManager->AllocNode(n->GetConcurrency() ? ENT_TRUE : ENT_FALSE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_CONCURRENCY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_CONCURRENCY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1134,7 +1134,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_CONCURRENCY(EvaluableN return source; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_VALUE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_VALUE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1158,7 +1158,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_VALUE(EvaluableNode *e return n; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_VALUE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_VALUE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1181,7 +1181,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_VALUE(EvaluableNode *e return source; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_EXPLODE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_EXPLODE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1245,7 +1245,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EXPLODE(EvaluableNode *en) return EvaluableNodeReference(result, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SPLIT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SPLIT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1381,7 +1381,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SPLIT(EvaluableNode *en) return retval; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1711,7 +1711,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en) } } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CONCAT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CONCAT(EvaluableNode *en, bool immediate_result) { //build string from all child nodes auto &ocn = en->GetOrderedChildNodes(); @@ -1739,7 +1739,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONCAT(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, s), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CRYPTO_SIGN(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CRYPTO_SIGN(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() < 2) @@ -1753,7 +1753,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CRYPTO_SIGN(EvaluableNode return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, signature), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CRYPTO_SIGN_VERIFY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CRYPTO_SIGN_VERIFY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() < 3) @@ -1768,7 +1768,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CRYPTO_SIGN_VERIFY(Evaluab return EvaluableNodeReference(evaluableNodeManager->AllocNode(valid_sig ? ENT_TRUE : ENT_FALSE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ENCRYPT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ENCRYPT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() < 2) @@ -1796,7 +1796,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ENCRYPT(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, cyphertext), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_DECRYPT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_DECRYPT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() < 2) @@ -1824,7 +1824,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DECRYPT(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, plaintext), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_PRINT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_PRINT(EvaluableNode *en, bool immediate_result) { for(auto &cn : en->GetOrderedChildNodes()) { @@ -1871,7 +1871,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_PRINT(EvaluableNode *en) return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_TOTAL_SIZE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_TOTAL_SIZE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp index fb719fca..83079ed6 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp @@ -22,7 +22,7 @@ #include #include -EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_ENTITY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_ENTITY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -41,7 +41,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_ENTITY(EvaluableN return EvaluableNodeReference(evaluableNodeManager->AllocNode(source_entity != nullptr ? 1.0 : 0.0), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINED_ENTITIES_and_COMPUTE_ON_CONTAINED_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINED_ENTITIES_and_COMPUTE_ON_CONTAINED_ENTITIES(EvaluableNode *en, bool immediate_result) { //not allowed if don't have a Entity to work within if(curEntity == nullptr) @@ -151,7 +151,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINED_ENTITIES_and_COM return EntityQueryCaches::GetEntitiesMatchingQuery(source_entity, conditionsBuffer, evaluableNodeManager, return_query_value); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_QUERY_and_COMPUTE_opcodes(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_QUERY_and_COMPUTE_opcodes(EvaluableNode *en, bool immediate_result) { //use stack to lock it in place, but copy it back to temporary before returning EvaluableNodeReference query_command(evaluableNodeManager->AllocNode(en->GetType()), true); @@ -176,7 +176,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_QUERY_and_COMPUTE_opcodes( return query_command; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_LABEL(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_LABEL(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -213,7 +213,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_LABEL(EvaluableNo return EvaluableNodeReference(evaluableNodeManager->AllocNode(contains_label ? ENT_TRUE : ENT_FALSE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_TO_ENTITIES_and_DIRECT_ASSIGN_TO_ENTITIES_and_ACCUM_TO_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_TO_ENTITIES_and_DIRECT_ASSIGN_TO_ENTITIES_and_ACCUM_TO_ENTITIES(EvaluableNode *en, bool immediate_result) { //not allowed if don't have a Entity to work within if(curEntity == nullptr) @@ -304,7 +304,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_TO_ENTITIES_and_DIR return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_assignments_successful ? ENT_TRUE : ENT_FALSE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE_FROM_ENTITY_and_DIRECT_RETRIEVE_FROM_ENTITY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE_FROM_ENTITY_and_DIRECT_RETRIEVE_FROM_ENTITY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -406,7 +406,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE_FROM_ENTITY_and_D } } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL_ENTITY_and_CALL_ENTITY_GET_CHANGES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL_ENTITY_and_CALL_ENTITY_GET_CHANGES(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -539,7 +539,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL_ENTITY_and_CALL_ENTIT return retval; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL_CONTAINER(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL_CONTAINER(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp index a86afccf..d7e5ec95 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp @@ -19,7 +19,7 @@ #include #include -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_COMMENTS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_COMMENTS(EvaluableNode *en, bool immediate_result) { if(curEntity == nullptr) return EvaluableNodeReference::Null(); @@ -108,7 +108,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_COMMENTS(Evalua return retval; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE_ENTITY_ROOT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE_ENTITY_ROOT(EvaluableNode *en, bool immediate_result) { if(curEntity == nullptr) return EvaluableNodeReference::Null(); @@ -136,7 +136,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE_ENTITY_ROOT(Evalu return target_entity->GetRoot(evaluableNodeManager, label_escape_increment); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_ENTITY_ROOTS_and_ACCUM_ENTITY_ROOTS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_ENTITY_ROOTS_and_ACCUM_ENTITY_ROOTS(EvaluableNode *en, bool immediate_result) { if(curEntity == nullptr) return EvaluableNodeReference::Null(); @@ -211,7 +211,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_ENTITY_ROOTS_and_AC return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_assignments_successful ? ENT_TRUE : ENT_FALSE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_RAND_SEED(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_RAND_SEED(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -231,7 +231,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_RAND_SEED(Evalu return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, rand_state_string), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_ENTITY_RAND_SEED(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_ENTITY_RAND_SEED(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); size_t num_params = ocn.size(); @@ -272,7 +272,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_ENTITY_RAND_SEED(Evalu return seed_node; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_ROOT_PERMISSION(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_ROOT_PERMISSION(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -290,7 +290,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_ROOT_PERMISSION return EvaluableNodeReference(evaluableNodeManager->AllocNode(asset_manager.DoesEntityHaveRootPermission(entity) ? ENT_TRUE : ENT_FALSE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_ENTITY_ROOT_PERMISSION(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_ENTITY_ROOT_PERMISSION(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -311,7 +311,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_ENTITY_ROOT_PERMISSION return id_node; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CREATE_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CREATE_ENTITIES(EvaluableNode *en, bool immediate_result) { //not allowed if don't have a Entity to create within if(curEntity == nullptr) @@ -377,7 +377,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CREATE_ENTITIES(EvaluableN return new_entity_ids_list; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CLONE_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CLONE_ENTITIES(EvaluableNode *en, bool immediate_result) { //not allowed if don't have a Entity to create within if(curEntity == nullptr) @@ -437,7 +437,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CLONE_ENTITIES(EvaluableNo return new_entity_ids_list; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_MOVE_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_MOVE_ENTITIES(EvaluableNode *en, bool immediate_result) { //not allowed if don't have a Entity to create within if(curEntity == nullptr) @@ -506,7 +506,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MOVE_ENTITIES(EvaluableNod return new_entity_ids_list; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_DESTROY_ENTITIES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_DESTROY_ENTITIES(EvaluableNode *en, bool immediate_result) { //not allowed if don't have a Entity to create within if(curEntity == nullptr) @@ -545,7 +545,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DESTROY_ENTITIES(Evaluable return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_destroys_successful ? ENT_TRUE : ENT_FALSE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_LOAD(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_LOAD(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -575,7 +575,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LOAD(EvaluableNode *en) return asset_manager.LoadResourcePath(resource_name, resource_base_path, file_type, evaluableNodeManager, escape_filename); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_LOAD_ENTITY_and_LOAD_PERSISTENT_ENTITY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_LOAD_ENTITY_and_LOAD_PERSISTENT_ENTITY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -644,7 +644,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LOAD_ENTITY_and_LOAD_PERSI return EvaluableNodeReference(GetTraversalIDPathFromAToB(evaluableNodeManager, curEntity, loaded_entity), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_STORE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_STORE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -699,7 +699,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_STORE(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode(successful_save ? ENT_TRUE : ENT_FALSE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_STORE_ENTITY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_STORE_ENTITY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp index d193aa03..22165eec 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp @@ -19,7 +19,7 @@ #include #include -EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -107,7 +107,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en) return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_TAIL(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_TAIL(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -235,7 +235,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAIL(EvaluableNode *en) return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_LAST(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_LAST(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -323,7 +323,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LAST(EvaluableNode *en) return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUNC(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUNC(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -449,7 +449,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUNC(EvaluableNode *en) return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_APPEND(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_APPEND(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -539,7 +539,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_APPEND(EvaluableNode *en) return new_list; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SIZE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SIZE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -566,7 +566,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SIZE(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode(static_cast(size)), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_RANGE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_RANGE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); size_t num_params = ocn.size(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp index 078aff7f..cf786e52 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp @@ -19,7 +19,7 @@ #include #include -EvaluableNodeReference Interpreter::InterpretNode_ENT_AND(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_AND(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() == 0) @@ -60,7 +60,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_AND(EvaluableNode *en) return cur; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_OR(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_OR(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() == 0) @@ -102,7 +102,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_OR(EvaluableNode *en) return evaluableNodeManager->ReuseOrAllocNode(cur, ENT_FALSE); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_XOR(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_XOR(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -140,7 +140,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_XOR(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode((num_true % 2 == 1) ? ENT_TRUE : ENT_FALSE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_NOT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_NOT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -153,7 +153,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NOT(EvaluableNode *en) return evaluableNodeManager->ReuseOrAllocNode(cur, is_true ? ENT_FALSE : ENT_TRUE); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_EQUAL(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_EQUAL(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -215,7 +215,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EQUAL(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_NEQUAL(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_NEQUAL(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -298,7 +298,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NEQUAL(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_not_equal ? ENT_TRUE : ENT_FALSE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -391,7 +391,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableN return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -485,7 +485,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_EQUALS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_EQUALS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -573,7 +573,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_EQUALS(EvaluableNode return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_NEQUALS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_NEQUALS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp index 3cd56157..36e8c1f7 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp @@ -20,7 +20,7 @@ #include #include -EvaluableNodeReference Interpreter::InterpretNode_ENT_ADD(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ADD(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -46,7 +46,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ADD(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -76,7 +76,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_MULTIPLY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_MULTIPLY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -102,7 +102,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MULTIPLY(EvaluableNode *en return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -160,7 +160,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_MODULUS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_MODULUS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -238,7 +238,7 @@ inline void NormalizeStartAndEndDigitToZerosPlace(double value, double base, boo end_digit = start_digit - max_num_digits; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_DIGITS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_DIGITS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); size_t num_params = ocn.size(); @@ -317,7 +317,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_DIGITS(EvaluableNode * return digits; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_DIGITS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_DIGITS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); size_t num_params = ocn.size(); @@ -436,7 +436,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_DIGITS(EvaluableNode * return EvaluableNodeReference(evaluableNodeManager->AllocNode(result_value), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_FLOOR(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_FLOOR(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -448,7 +448,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FLOOR(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CEILING(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CEILING(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -460,7 +460,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CEILING(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -503,7 +503,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_EXPONENT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_EXPONENT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -515,7 +515,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EXPONENT(EvaluableNode *en return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_LOG(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_LOG(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -534,7 +534,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LOG(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SIN(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SIN(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -546,7 +546,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SIN(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ASIN(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ASIN(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -558,7 +558,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASIN(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_COS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_COS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -570,7 +570,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COS(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -582,7 +582,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOS(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_TAN(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_TAN(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -594,7 +594,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAN(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ATAN(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ATAN(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -616,7 +616,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ATAN(EvaluableNode *en) return EvaluableNodeReference::Null(); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SINH(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SINH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -628,7 +628,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SINH(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ASINH(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ASINH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -640,7 +640,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASINH(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_COSH(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_COSH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -652,7 +652,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COSH(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOSH(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOSH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -664,7 +664,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOSH(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_TANH(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_TANH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -676,7 +676,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TANH(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ATANH(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ATANH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -688,7 +688,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ATANH(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ERF(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ERF(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -700,7 +700,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ERF(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_TGAMMA(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_TGAMMA(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -712,7 +712,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TGAMMA(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_LGAMMA(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_LGAMMA(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -724,7 +724,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LGAMMA(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SQRT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SQRT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -736,7 +736,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SQRT(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_POW(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_POW(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -748,7 +748,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_POW(EvaluableNode *en) return EvaluableNodeReference(evaluableNodeManager->AllocNode(std::pow(f1, f2)), true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ABS(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ABS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -760,7 +760,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ABS(EvaluableNode *en) return EvaluableNodeReference(retval, true); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_MAX(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_MAX(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -826,7 +826,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MAX(EvaluableNode *en) return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_MIN(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_MIN(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -892,7 +892,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MIN(EvaluableNode *en) return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_DOT_PRODUCT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_DOT_PRODUCT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() < 2) @@ -1007,7 +1007,7 @@ inline void GetChildNodesAsENImmediateValueArray(EvaluableNode *node, std::vecto } } -EvaluableNodeReference Interpreter::InterpretNode_ENT_GENERALIZED_DISTANCE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_GENERALIZED_DISTANCE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1132,7 +1132,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GENERALIZED_DISTANCE(Evalu return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ENTROPY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ENTROPY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp index 50b8dea1..01c86875 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp @@ -19,7 +19,7 @@ #include #include -EvaluableNodeReference Interpreter::InterpretNode_ENT_REWRITE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_REWRITE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -54,7 +54,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_REWRITE(EvaluableNode *en) return EvaluableNodeReference(result, false); //can't make any guarantees about the new code } -EvaluableNodeReference Interpreter::InterpretNode_ENT_MAP(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_MAP(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -350,7 +350,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MAP(EvaluableNode *en) return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_FILTER(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_FILTER(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -589,7 +589,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FILTER(EvaluableNode *en) return result_list; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_WEAVE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_WEAVE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -707,7 +707,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_WEAVE(EvaluableNode *en) return woven_list; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_REDUCE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_REDUCE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -771,7 +771,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_REDUCE(EvaluableNode *en) return previous_result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_APPLY(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_APPLY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -822,7 +822,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_APPLY(EvaluableNode *en) return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_REVERSE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_REVERSE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -844,7 +844,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_REVERSE(EvaluableNode *en) return list; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_SORT(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_SORT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -895,7 +895,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SORT(EvaluableNode *en) } } -EvaluableNodeReference Interpreter::InterpretNode_ENT_INDICES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_INDICES(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -941,7 +941,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_INDICES(EvaluableNode *en) return index_list; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_VALUES(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_VALUES(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1032,7 +1032,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_VALUES(EvaluableNode *en) return EvaluableNodeReference(result, container.unique); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_INDEX(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_INDEX(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1055,7 +1055,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_INDEX(EvaluableNo return evaluableNodeManager->ReuseOrAllocOneOfNodes(index, container, result); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_VALUE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_VALUE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1123,7 +1123,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_VALUE(EvaluableNo return evaluableNodeManager->ReuseOrAllocOneOfNodes(value, collection, result); } -EvaluableNodeReference Interpreter::InterpretNode_ENT_REMOVE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_REMOVE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1235,7 +1235,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_REMOVE(EvaluableNode *en) return container; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_KEEP(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_KEEP(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1418,7 +1418,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_KEEP(EvaluableNode *en) return container; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSOCIATE(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSOCIATE(EvaluableNode *en, bool immediate_result) { //use stack to lock it in place, but copy it back to temporary before returning EvaluableNodeReference new_assoc(evaluableNodeManager->AllocNode(ENT_ASSOC), true); @@ -1499,7 +1499,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSOCIATE(EvaluableNode *e return new_assoc; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_ZIP(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_ZIP(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1619,7 +1619,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ZIP(EvaluableNode *en) return result; } -EvaluableNodeReference Interpreter::InterpretNode_ENT_UNZIP(EvaluableNode *en) +EvaluableNodeReference Interpreter::InterpretNode_ENT_UNZIP(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); From 4b716a0a32d9e104462136ba3d2ecddd6fbd70b3 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Wed, 13 Dec 2023 11:57:40 -0500 Subject: [PATCH 02/55] 18652: Refactors EvaluableNodeReference access --- src/Amalgam/entity/Entity.cpp | 4 +- src/Amalgam/entity/EntityManipulation.cpp | 12 +++--- .../evaluablenode/EvaluableNodeManagement.h | 31 ++++++++++++++++ .../EvaluableNodeTreeFunctions.cpp | 12 ++---- src/Amalgam/interpreter/Interpreter.cpp | 10 ++--- src/Amalgam/interpreter/Interpreter.h | 4 +- .../interpreter/InterpreterOpcodesBase.cpp | 24 +++++------- .../InterpreterOpcodesDataTypes.cpp | 23 +++++------- .../InterpreterOpcodesEntityAccess.cpp | 10 ++--- .../InterpreterOpcodesListManipulation.cpp | 8 ++-- .../interpreter/InterpreterOpcodesMath.cpp | 6 +-- .../InterpreterOpcodesTransformations.cpp | 37 ++++++++----------- src/Amalgam/out.txt | 18 ++++----- 13 files changed, 102 insertions(+), 97 deletions(-) diff --git a/src/Amalgam/entity/Entity.cpp b/src/Amalgam/entity/Entity.cpp index c0713794..e3da1430 100644 --- a/src/Amalgam/entity/Entity.cpp +++ b/src/Amalgam/entity/Entity.cpp @@ -887,7 +887,7 @@ void Entity::SetRoot(EvaluableNode *_code, bool allocated_with_entity_enm, Evalu else { auto code_copy = evaluableNodeManager.DeepAllocCopy(_code, metadata_modifier); - evaluableNodeManager.SetRootNode(code_copy.reference); + evaluableNodeManager.SetRootNode(code_copy); } //keep reference for current root @@ -919,7 +919,7 @@ void Entity::SetRoot(EvaluableNode *_code, bool allocated_with_entity_enm, Evalu void Entity::SetRoot(std::string &code_string, EvaluableNodeManager::EvaluableNodeMetadataModifier metadata_modifier, std::vector *write_listeners) { EvaluableNodeReference new_code = Parser::Parse(code_string, &evaluableNodeManager); - SetRoot(new_code.reference, true, metadata_modifier, write_listeners); + SetRoot(new_code, true, metadata_modifier, write_listeners); } void Entity::AccumRoot(EvaluableNodeReference accum_code, bool allocated_with_entity_enm, EvaluableNodeManager::EvaluableNodeMetadataModifier metadata_modifier, std::vector *write_listeners) diff --git a/src/Amalgam/entity/EntityManipulation.cpp b/src/Amalgam/entity/EntityManipulation.cpp index 822fbe58..34c89d12 100644 --- a/src/Amalgam/entity/EntityManipulation.cpp +++ b/src/Amalgam/entity/EntityManipulation.cpp @@ -20,8 +20,8 @@ Entity *EntityManipulation::EntitiesMergeMethod::MergeValues(Entity *a, Entity * merged_entity->SetRandomStream(b->GetRandomStream()); //merge entitys' code - EvaluableNode *code_a = (a != nullptr ? a->GetRoot().reference : nullptr); - EvaluableNode *code_b = (b != nullptr ? b->GetRoot().reference : nullptr); + EvaluableNodeReference code_a = (a != nullptr ? a->GetRoot() : EvaluableNodeReference::Null()); + EvaluableNodeReference code_b = (b != nullptr ? b->GetRoot() : EvaluableNodeReference::Null()); EvaluableNodeTreeManipulation::NodesMergeMethod mm(&merged_entity->evaluableNodeManager, keepAllOfBoth, true); EvaluableNode *result = mm.MergeValues(code_a, code_b); @@ -44,8 +44,8 @@ Entity *EntityManipulation::EntitiesMergeForDifferenceMethod::MergeValues(Entity Entity *result = new Entity(); //compare entitys' code - EvaluableNode *code_a = (a != nullptr ? a->GetRoot().reference : nullptr); - EvaluableNode *code_b = (b != nullptr ? b->GetRoot().reference : nullptr); + EvaluableNodeReference code_a = (a != nullptr ? a->GetRoot() : EvaluableNodeReference::Null()); + EvaluableNodeReference code_b = (b != nullptr ? b->GetRoot() : EvaluableNodeReference::Null()); if(a != nullptr) aEntitiesIncludedFromB[b] = a; @@ -125,8 +125,8 @@ Entity *EntityManipulation::EntitiesMixMethod::MergeValues(Entity *a, Entity *b, merged_entity->SetRandomStream(b->GetRandomStream()); //merge entity's code - EvaluableNode *code_a = (a != nullptr ? a->GetRoot().reference : nullptr); - EvaluableNode *code_b = (b != nullptr ? b->GetRoot().reference : nullptr); + EvaluableNodeReference code_a = (a != nullptr ? a->GetRoot() : EvaluableNodeReference::Null()); + EvaluableNodeReference code_b = (b != nullptr ? b->GetRoot() : EvaluableNodeReference::Null()); EvaluableNodeTreeManipulation::NodesMixMethod mm(interpreter->randomStream.CreateOtherStreamViaRand(), &merged_entity->evaluableNodeManager, fractionA, fractionB, similarMixChance); diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index 33fad637..3a438f81 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -66,6 +66,22 @@ class EvaluableNodeReference return EvaluableNodeReference(nullptr, true); } + inline void SetReference(EvaluableNode *_reference) + { + reference = _reference; + } + + inline void SetReference(EvaluableNode *_reference, bool _unique) + { + reference = _reference; + unique = _unique; + } + + inline EvaluableNode *&GetReference() + { + return reference; + } + //allow to use as an EvaluableNode * constexpr operator EvaluableNode *&() { return reference; } @@ -74,7 +90,9 @@ class EvaluableNodeReference constexpr EvaluableNode *operator->() { return reference; } +protected: EvaluableNode *reference; +public: //this is the only reference to the result bool unique; @@ -201,6 +219,19 @@ class EvaluableNodeManager }; EvaluableNode *AllocNode(EvaluableNode *original, EvaluableNodeMetadataModifier metadata_modifier = ENMM_NO_CHANGE); + //ensures that the top node is modifiable -- will allocate the node if necessary, + // and if the result and any child nodes are all unique, then it will return an EvaluableNodeReference that is unique + inline void EnsureNodeIsModifiable(EvaluableNodeReference &original, + EvaluableNodeMetadataModifier metadata_modifier = ENMM_NO_CHANGE) + { + if(original.unique) + return; + + EvaluableNode *copy = AllocNode(original.GetReference(), metadata_modifier); + //the copy will only be unique if all child nodes are unique or there are no child nodes + original = EvaluableNodeReference(copy, original.unique || (copy->GetNumChildNodes() == 0)); + } + //attempts to reuse candidate if it is unique and change it into the specified type //if candidate is not unique, then it allocates and returns a new node inline EvaluableNodeReference ReuseOrAllocNode(EvaluableNodeReference candidate, EvaluableNodeType type) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeTreeFunctions.cpp b/src/Amalgam/evaluablenode/EvaluableNodeTreeFunctions.cpp index 17cc3f17..acb531be 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeTreeFunctions.cpp +++ b/src/Amalgam/evaluablenode/EvaluableNodeTreeFunctions.cpp @@ -441,8 +441,7 @@ EvaluableNodeReference AccumulateEvaluableNodeIntoEvaluableNode(EvaluableNodeRef { double cur_value = EvaluableNode::ToNumber(value_destination_node); double inc_value = EvaluableNode::ToNumber(variable_value_node); - value_destination_node.reference = enm->AllocNode(cur_value + inc_value); - value_destination_node.unique = true; + value_destination_node.SetReference(enm->AllocNode(cur_value + inc_value), true); } else if(value_destination_node->IsAssociativeArray()) { @@ -470,16 +469,14 @@ EvaluableNodeReference AccumulateEvaluableNodeIntoEvaluableNode(EvaluableNodeRef enm->FreeNodeIfPossible(variable_value_node); - value_destination_node.reference = new_list; + value_destination_node.SetReference(new_list, value_destination_node.unique && variable_value_node.unique); value_destination_node->SetNeedCycleCheck(true); - value_destination_node.unique = (value_destination_node.unique && variable_value_node.unique); } else if(value_destination_node->IsStringValue()) { std::string cur_value = EvaluableNode::ToString(value_destination_node); std::string inc_value = EvaluableNode::ToString(variable_value_node); - value_destination_node.reference = enm->AllocNode(ENT_STRING, cur_value.append(inc_value)); - value_destination_node.unique = true; + value_destination_node.SetReference(enm->AllocNode(ENT_STRING, cur_value.append(inc_value)), true); } else //add ordered child node { @@ -512,9 +509,8 @@ EvaluableNodeReference AccumulateEvaluableNodeIntoEvaluableNode(EvaluableNodeRef new_list->AppendOrderedChildNode(variable_value_node); } - value_destination_node.reference = new_list; + value_destination_node.SetReference(new_list, value_destination_node.unique &&variable_value_node.unique); value_destination_node->SetNeedCycleCheck(true); - value_destination_node.unique = (value_destination_node.unique && variable_value_node.unique); } return value_destination_node; diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index 045907dc..f9eea3a0 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -406,18 +406,16 @@ EvaluableNodeReference Interpreter::ConvertArgsToCallStack(EvaluableNodeReferenc //ensure have arguments if(args == nullptr) { - args.reference = enm->AllocNode(ENT_ASSOC); - args.unique = true; + args.SetReference(enm->AllocNode(ENT_ASSOC), true); } else if(!args->IsAssociativeArray()) { enm->FreeNodeTreeIfPossible(args); - args.reference = enm->AllocNode(ENT_ASSOC); - args.unique = true; + args.SetReference(enm->AllocNode(ENT_ASSOC), true); } else if(!args.unique) { - args.reference = enm->AllocNode(args); + args.SetReference(enm->AllocNode(args)); } EvaluableNode *call_stack = enm->AllocNode(ENT_LIST); @@ -708,7 +706,7 @@ EvaluableNode **Interpreter::TraverseToDestinationFromTraversalPathList(Evaluabl } else //it's only a single value; use default list length of 1 { - address_list = &(tpl.reference); + address_list = &tpl.GetReference(); } size_t max_num_nodes = 0; diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index 4411e542..feb91d00 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -109,12 +109,12 @@ class Interpreter if(EvaluableNode::IsAssociativeArray(new_context)) { if(!new_context.unique) - new_context.reference = evaluableNodeManager->AllocNode(new_context); + new_context.SetReference(evaluableNodeManager->AllocNode(new_context)); } else //not assoc, make a new one { evaluableNodeManager->FreeNodeTreeIfPossible(new_context); - new_context.reference = evaluableNodeManager->AllocNode(ENT_ASSOC); + new_context.SetReference(evaluableNodeManager->AllocNode(ENT_ASSOC)); } //just in case a variable is added which needs cycle checks diff --git a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp index 41c17b9c..94d2aa09 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp @@ -368,7 +368,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_PARALLEL(EvaluableNode *en concurrency_manager.GetCallStackWriteMutex()); interpreter.evaluableNodeManager->FreeNodeTreeIfPossible(result); - result.reference = EvaluableNodeReference::Null(); + result = EvaluableNodeReference::Null(); interpreter.memoryModificationLock.unlock(); return result; @@ -842,8 +842,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_and_ACCUM(Evaluable { //retrieve value_destination_node EvaluableNodeReference value_destination_node; - value_destination_node.reference = *value_destination; - value_destination_node.unique = false; + value_destination_node.SetReference(*value_destination, false); #ifdef MULTITHREAD_SUPPORT //if editing a shared variable, then need to make a copy before editing in place to prevent another thread from reading the data structure mid-edit @@ -899,8 +898,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_and_ACCUM(Evaluable { //create destination reference EvaluableNodeReference value_destination_node; - value_destination_node.reference = *value_destination; - value_destination_node.unique = false; + value_destination_node.SetReference(*value_destination, false); #ifdef MULTITHREAD_SUPPORT //if editing a shared variable, then need to make a copy before editing in place to prevent another thread from reading the data structure mid-edit @@ -970,8 +968,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_and_ACCUM(Evaluable { //create destination reference EvaluableNodeReference value_destination_node; - value_destination_node.reference = *copy_destination; - value_destination_node.unique = false; + value_destination_node.SetReference(*copy_destination, false); EvaluableNodeReference variable_value_node = AccumulateEvaluableNodeIntoEvaluableNode(value_destination_node, new_value, evaluableNodeManager); @@ -1010,8 +1007,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE(EvaluableNode *en else if(to_lookup->IsAssociativeArray()) { //need to return an assoc, so see if need to make copy - if(!to_lookup.unique) - to_lookup.reference = evaluableNodeManager->AllocNode(to_lookup); + evaluableNodeManager->EnsureNodeIsModifiable(to_lookup); //overwrite values in the ordered for(auto &[cn_id, cn] : to_lookup->GetMappedChildNodesReference()) @@ -1027,9 +1023,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE(EvaluableNode *en } else //ordered params { - //need to return an assoc, so see if need to make copy - if(!to_lookup.unique) - to_lookup.reference = evaluableNodeManager->AllocNode(to_lookup); + evaluableNodeManager->EnsureNodeIsModifiable(to_lookup); //overwrite values in the ordered for(auto &cn : to_lookup->GetOrderedChildNodes()) @@ -1069,7 +1063,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET(EvaluableNode *en, boo //if just a single index passed to get if(ocn_size == 2) { - EvaluableNode **target = InterpretNodeIntoDestinationFromTraversalPathList(&source.reference, ocn[1], false); + EvaluableNode **target = InterpretNodeIntoDestinationFromTraversalPathList(&source.GetReference(), ocn[1], false); node_stack.PopEvaluableNode(); @@ -1089,7 +1083,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET(EvaluableNode *en, boo for(size_t param_index = 1; param_index < ocn_size; param_index++) { - EvaluableNode **target = InterpretNodeIntoDestinationFromTraversalPathList(&source.reference, ocn[param_index], false); + EvaluableNode **target = InterpretNodeIntoDestinationFromTraversalPathList(&source.GetReference(), ocn[param_index], false); if(target != nullptr) retrieved_list->AppendOrderedChildNode(*target); else @@ -1125,7 +1119,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_and_REPLACE(EvaluableN { //find replacement location, make sure it's a valid target EvaluableNode *previous_result = result; - EvaluableNode **copy_destination = InterpretNodeIntoDestinationFromTraversalPathList(&result.reference, ocn[replace_change_index], true); + EvaluableNode **copy_destination = InterpretNodeIntoDestinationFromTraversalPathList(&result.GetReference(), ocn[replace_change_index], true); //if the target changed, keep track of the proper reference if(result != previous_result) { diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index a1e1b61c..7ed88bc5 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -251,8 +251,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_TYPE(EvaluableNode *en if(source == nullptr) source = EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_NULL), true); - if(!source.unique) - source.reference = evaluableNodeManager->AllocNode(source); + evaluableNodeManager->EnsureNodeIsModifiable(source); auto node_stack = CreateInterpreterNodeStackStateSaver(source); @@ -947,8 +946,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_LABELS(EvaluableNode * if(source == nullptr) source = EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_NULL), true); - if(!source.unique) - source.reference = evaluableNodeManager->AllocNode(source); + evaluableNodeManager->EnsureNodeIsModifiable(source); auto node_stack = CreateInterpreterNodeStackStateSaver(source); @@ -1002,8 +1000,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ZIP_LABELS(EvaluableNode * //start assuming that the copy will be unique, but set to not unique if any chance the assumption // might not hold EvaluableNodeReference retval = source; - if(!source.unique) - retval = EvaluableNodeReference(evaluableNodeManager->AllocNode(source), true); + evaluableNodeManager->EnsureNodeIsModifiable(source); auto &label_list_ocn = label_list->GetOrderedChildNodesReference(); @@ -1088,7 +1085,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_COMMENTS(EvaluableNode if(source == nullptr) source = EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_NULL), true); if(!source.unique) - source.reference = evaluableNodeManager->AllocNode(source); + source.SetReference(evaluableNodeManager->AllocNode(source)); auto node_stack = CreateInterpreterNodeStackStateSaver(source); @@ -1122,8 +1119,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_CONCURRENCY(EvaluableN auto source = InterpretNode(ocn[0]); if(source == nullptr) source = EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_NULL), true); - else if(!source.unique) - source.reference = evaluableNodeManager->AllocNode(source); + else + evaluableNodeManager->EnsureNodeIsModifiable(source); auto node_stack = CreateInterpreterNodeStackStateSaver(source); @@ -1150,9 +1147,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_VALUE(EvaluableNode *e } else { - n.reference = evaluableNodeManager->AllocNode(n, EvaluableNodeManager::ENMM_REMOVE_ALL); - if(n->GetNumChildNodes() == 0) - n.unique = true; + evaluableNodeManager->EnsureNodeIsModifiable(n, EvaluableNodeManager::ENMM_REMOVE_ALL); } return n; @@ -1168,8 +1163,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_VALUE(EvaluableNode *e auto source = InterpretNode(ocn[0]); if(source == nullptr) source = EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_NULL), true); - if(!source.unique) - source.reference = evaluableNodeManager->AllocNode(source); + else + evaluableNodeManager->EnsureNodeIsModifiable(source); auto node_stack = CreateInterpreterNodeStackStateSaver(source); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp index 83079ed6..5454c5d9 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp @@ -352,7 +352,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE_FROM_ENTITY_and_D //need to return an assoc, so see if need to make copy; will overwrite all values if(!to_lookup.unique) { - to_lookup = EvaluableNodeReference(evaluableNodeManager->AllocNode(to_lookup), true); + evaluableNodeManager->EnsureNodeIsModifiable(to_lookup); node_stack.PushEvaluableNode(to_lookup); } @@ -360,7 +360,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE_FROM_ENTITY_and_D for(auto &[cn_id, cn] : to_lookup->GetMappedChildNodesReference()) { //if there are values passed in, free them to be clobbered - cnr.reference = cn; + cnr.SetReference(cn); evaluableNodeManager->FreeNodeTreeIfPossible(cnr); ExecutionCycleCount num_steps_executed = 0; @@ -381,7 +381,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE_FROM_ENTITY_and_D //need to return an assoc, so see if need to make copy; will overwrite all values if(!to_lookup.unique) { - to_lookup = EvaluableNodeReference(evaluableNodeManager->AllocNode(to_lookup), true); + evaluableNodeManager->EnsureNodeIsModifiable(to_lookup); node_stack.PushEvaluableNode(to_lookup); } @@ -391,7 +391,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE_FROM_ENTITY_and_D StringInternPool::StringID label_sid = EvaluableNode::ToStringIDIfExists(cn); //if there are values passed in, free them to be clobbered - cnr.reference = cn; + cnr.SetReference(cn); evaluableNodeManager->FreeNodeTreeIfPossible(cnr); ExecutionCycleCount num_steps_executed = 0; @@ -526,7 +526,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL_ENTITY_and_CALL_ENTIT //delete the write listener and all of its memory delete wl; - retval.reference = list; + retval.SetReference(list); retval.SetNeedCycleCheck(true); //can't count on that due to things written in the write listener } diff --git a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp index 22165eec..8c83bd61 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp @@ -132,7 +132,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAIL(EvaluableNode *en, bo if(!list.unique) { //make a copy so can edit node - list.reference = evaluableNodeManager->AllocNode(list); + evaluableNodeManager->EnsureNodeIsModifiable(list); node_stack.PopEvaluableNode(); node_stack.PushEvaluableNode(list); } @@ -163,7 +163,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAIL(EvaluableNode *en, bo if(!list.unique) { //make a copy so can edit node - list.reference = evaluableNodeManager->AllocNode(list); + evaluableNodeManager->EnsureNodeIsModifiable(list); node_stack.PopEvaluableNode(); node_stack.PushEvaluableNode(list); } @@ -346,7 +346,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUNC(EvaluableNode *en, b if(!list.unique) { //make a copy so can edit node - list.reference = evaluableNodeManager->AllocNode(list); + evaluableNodeManager->EnsureNodeIsModifiable(list); node_stack.PopEvaluableNode(); node_stack.PushEvaluableNode(list); } @@ -377,7 +377,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUNC(EvaluableNode *en, b if(!list.unique) { //make a copy so can edit node - list.reference = evaluableNodeManager->AllocNode(list); + evaluableNodeManager->EnsureNodeIsModifiable(list); node_stack.PopEvaluableNode(); node_stack.PushEvaluableNode(list); } diff --git a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp index 36e8c1f7..934e865c 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp @@ -928,15 +928,13 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DOT_PRODUCT(EvaluableNode //if not an assoc, then convert if(!elements1_assoc) { - if(!elements1.unique) - elements1.reference = evaluableNodeManager->AllocNode(elements1); + evaluableNodeManager->EnsureNodeIsModifiable(elements1); elements1->ConvertOrderedListToNumberedAssoc(); } if(!elements2_assoc) { - if(!elements2.unique) - elements2.reference = evaluableNodeManager->AllocNode(elements2); + evaluableNodeManager->EnsureNodeIsModifiable(elements2); elements2->ConvertOrderedListToNumberedAssoc(); } diff --git a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp index 01c86875..599c854d 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp @@ -370,8 +370,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FILTER(EvaluableNode *en, EvaluableNodeReference result_list(list, list.unique); //need to edit the list itself, so if not unique, make at least the top node unique - if(!result_list.unique) - result_list.reference = evaluableNodeManager->AllocNode(list); + evaluableNodeManager->EnsureNodeIsModifiable(result_list); if(result_list->IsAssociativeArray()) { @@ -783,8 +782,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_APPLY(EvaluableNode *en, b if(source == nullptr) return EvaluableNodeReference::Null(); - if(!source.unique) - source.reference = evaluableNodeManager->AllocNode(source); + evaluableNodeManager->EnsureNodeIsModifiable(source); auto node_stack = CreateInterpreterNodeStackStateSaver(source); @@ -835,8 +833,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_REVERSE(EvaluableNode *en, return EvaluableNodeReference::Null(); //make sure it is an editable copy - if(!list.unique) - list.reference = evaluableNodeManager->AllocNode(list); + evaluableNodeManager->EnsureNodeIsModifiable(list); auto &list_ocn = list->GetOrderedChildNodes(); std::reverse(begin(list_ocn), end(list_ocn)); @@ -859,8 +856,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SORT(EvaluableNode *en, bo return EvaluableNodeReference::Null(); //make sure it is an editable copy - if(!list.unique) - list.reference = evaluableNodeManager->AllocNode(list); + evaluableNodeManager->EnsureNodeIsModifiable(list); std::sort(begin(list->GetOrderedChildNodes()), end(list->GetOrderedChildNodes()), EvaluableNode::IsStrictlyLessThan); @@ -881,8 +877,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SORT(EvaluableNode *en, bo return EvaluableNodeReference::Null(); //make sure it is an editable copy - if(!list.unique) - list.reference = evaluableNodeManager->AllocNode(list); + evaluableNodeManager->EnsureNodeIsModifiable(list); CustomEvaluableNodeComparator comparator(this, function, list); @@ -913,7 +908,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_INDICES(EvaluableNode *en, if(container->IsAssociativeArray()) { auto &container_mcn = container->GetMappedChildNodesReference(); - index_list.reference = evaluableNodeManager->AllocListNodeWithOrderedChildNodes(ENT_STRING, container_mcn.size()); + index_list.SetReference(evaluableNodeManager->AllocListNodeWithOrderedChildNodes(ENT_STRING, container_mcn.size())); //create all the string references at once for speed (especially multithreading) string_intern_pool.CreateStringReferences(container_mcn, [](auto n) { return n.first; }); @@ -926,14 +921,14 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_INDICES(EvaluableNode *en, else if(container->IsOrderedArray()) { size_t num_ordered_nodes = container->GetOrderedChildNodesReference().size(); - index_list.reference = evaluableNodeManager->AllocListNodeWithOrderedChildNodes(ENT_NUMBER, num_ordered_nodes); + index_list.SetReference(evaluableNodeManager->AllocListNodeWithOrderedChildNodes(ENT_NUMBER, num_ordered_nodes)); auto &index_list_ocn = index_list->GetOrderedChildNodes(); for(size_t i = 0; i < num_ordered_nodes; i++) index_list_ocn[i]->SetNumberValue(static_cast(i)); } else //no child nodes, just alloc an empty list - index_list.reference = evaluableNodeManager->AllocNode(ENT_LIST); + index_list.SetReference(evaluableNodeManager->AllocNode(ENT_LIST)); //none of the original container is needed evaluableNodeManager->FreeNodeTreeIfPossible(container); @@ -1049,7 +1044,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_INDEX(EvaluableNo //get index to look up (will attempt to reuse this node below) auto index = InterpretNodeForImmediateUse(ocn[1]); - EvaluableNode **target = TraverseToDestinationFromTraversalPathList(&container.reference, index, false); + EvaluableNode **target = TraverseToDestinationFromTraversalPathList(&container.GetReference(), index, false); EvaluableNodeType result = (target != nullptr ? ENT_TRUE : ENT_FALSE); return evaluableNodeManager->ReuseOrAllocOneOfNodes(index, container, result); @@ -1135,8 +1130,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_REMOVE(EvaluableNode *en, if(container == nullptr) return EvaluableNodeReference::Null(); //make sure it's editable - if(!container.unique) - container.reference = evaluableNodeManager->AllocNode(container); + evaluableNodeManager->EnsureNodeIsModifiable(container); auto node_stack = CreateInterpreterNodeStackStateSaver(container); @@ -1155,7 +1149,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_REMOVE(EvaluableNode *en, if(container->IsAssociativeArray()) { StringInternPool::StringID key_sid = EvaluableNode::ToStringIDIfExists(indices); - removed_node.reference = container->EraseMappedChildNode(key_sid); + removed_node.SetReference(container->EraseMappedChildNode(key_sid)); } else if(container->IsOrderedArray()) { @@ -1172,7 +1166,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_REMOVE(EvaluableNode *en, //if the position is valid, erase it if(actual_pos >= 0 && actual_pos < container_ocn.size()) { - removed_node.reference = container_ocn[actual_pos]; + removed_node.SetReference(container_ocn[actual_pos]); container_ocn.erase(begin(container_ocn) + actual_pos); } } @@ -1186,7 +1180,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_REMOVE(EvaluableNode *en, for(auto &cn : indices_ocn) { StringInternPool::StringID key_sid = EvaluableNode::ToStringIDIfExists(cn); - removed_node.reference = container->EraseMappedChildNode(key_sid); + removed_node.SetReference(container->EraseMappedChildNode(key_sid)); evaluableNodeManager->FreeNodeTreeIfPossible(removed_node); } } @@ -1223,7 +1217,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_REMOVE(EvaluableNode *en, if(index >= container_ocn.size()) continue; - removed_node.reference = container_ocn[index]; + removed_node.SetReference(container_ocn[index]); container_ocn.erase(begin(container_ocn) + index); evaluableNodeManager->FreeNodeTreeIfPossible(removed_node); } @@ -1247,8 +1241,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_KEEP(EvaluableNode *en, bo if(container == nullptr) return EvaluableNodeReference::Null(); //make sure it's editable - if(!container.unique) - container.reference = evaluableNodeManager->AllocNode(container); + evaluableNodeManager->EnsureNodeIsModifiable(container); auto node_stack = CreateInterpreterNodeStackStateSaver(container); diff --git a/src/Amalgam/out.txt b/src/Amalgam/out.txt index 543b4150..440a5d27 100644 --- a/src/Amalgam/out.txt +++ b/src/Amalgam/out.txt @@ -1252,7 +1252,7 @@ current_index: 2 interpreter "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" raaa 2 rwww 1 - start_time 1701560610.772288 + start_time 1702486622.920032 www 1 x 12 zz 10 @@ -1295,7 +1295,7 @@ current_index: 2 interpreter "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" raaa 2 rwww 1 - start_time 1701560610.772288 + start_time 1702486622.920032 www 1 x 12 zz 10 @@ -1337,7 +1337,7 @@ current_index: 2 interpreter "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" raaa 2 rwww 1 - start_time 1701560610.772288 + start_time 1702486622.920032 www 1 x 12 zz 10 @@ -1605,7 +1605,7 @@ e: - .inf 25: (assoc a 1) -current date-time in epoch: 2023-12-02-18.43.31.0723590 +current date-time in epoch: 2023-12-13-11.57.03.1841500 2020-06-07 00:22:59 1391230800 1391230800 @@ -3446,7 +3446,7 @@ deep sets --set_entity_root_permission-- RootTest -1701560611.471558 +1702486623.365415 (true) RootTest @@ -3670,7 +3670,7 @@ hello ) ) ) - (set_entity_rand_seed new_entity "<¢õ®¦gR0Ñ”-I´»ÿ") + (set_entity_rand_seed new_entity "MEÛI4 j0Ñ”-I´»ÿ") (set_entity_rand_seed (first (create_entities @@ -3680,7 +3680,7 @@ hello ) ) ) - "’‰<ö°ÿ°öXe/·äï$ÿ" + "ðPzfò]! ¸ rýÿ" ) (set_entity_rand_seed (first @@ -3713,7 +3713,7 @@ hello ) ) ) - (set_entity_rand_seed new_entity "<¢õ®¦gR0Ñ”-I´»ÿ") + (set_entity_rand_seed new_entity "MEÛI4 j0Ñ”-I´»ÿ") (set_entity_rand_seed (first (create_entities @@ -4660,4 +4660,4 @@ Expecting 1000: 1000 concurrent entity writes successful: (true) --total execution time-- -1.2860238552093506 +1.009415864944458 From 568797c409c9dba1c489d3e2a7597dc4bfccd497 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Wed, 13 Dec 2023 11:58:11 -0500 Subject: [PATCH 03/55] 18652: Undoes check-in of out.txt --- src/Amalgam/out.txt | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/Amalgam/out.txt b/src/Amalgam/out.txt index 440a5d27..543b4150 100644 --- a/src/Amalgam/out.txt +++ b/src/Amalgam/out.txt @@ -1252,7 +1252,7 @@ current_index: 2 interpreter "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" raaa 2 rwww 1 - start_time 1702486622.920032 + start_time 1701560610.772288 www 1 x 12 zz 10 @@ -1295,7 +1295,7 @@ current_index: 2 interpreter "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" raaa 2 rwww 1 - start_time 1702486622.920032 + start_time 1701560610.772288 www 1 x 12 zz 10 @@ -1337,7 +1337,7 @@ current_index: 2 interpreter "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" raaa 2 rwww 1 - start_time 1702486622.920032 + start_time 1701560610.772288 www 1 x 12 zz 10 @@ -1605,7 +1605,7 @@ e: - .inf 25: (assoc a 1) -current date-time in epoch: 2023-12-13-11.57.03.1841500 +current date-time in epoch: 2023-12-02-18.43.31.0723590 2020-06-07 00:22:59 1391230800 1391230800 @@ -3446,7 +3446,7 @@ deep sets --set_entity_root_permission-- RootTest -1702486623.365415 +1701560611.471558 (true) RootTest @@ -3670,7 +3670,7 @@ hello ) ) ) - (set_entity_rand_seed new_entity "MEÛI4 j0Ñ”-I´»ÿ") + (set_entity_rand_seed new_entity "<¢õ®¦gR0Ñ”-I´»ÿ") (set_entity_rand_seed (first (create_entities @@ -3680,7 +3680,7 @@ hello ) ) ) - "ðPzfò]! ¸ rýÿ" + "’‰<ö°ÿ°öXe/·äï$ÿ" ) (set_entity_rand_seed (first @@ -3713,7 +3713,7 @@ hello ) ) ) - (set_entity_rand_seed new_entity "MEÛI4 j0Ñ”-I´»ÿ") + (set_entity_rand_seed new_entity "<¢õ®¦gR0Ñ”-I´»ÿ") (set_entity_rand_seed (first (create_entities @@ -4660,4 +4660,4 @@ Expecting 1000: 1000 concurrent entity writes successful: (true) --total execution time-- -1.009415864944458 +1.2860238552093506 From 3e15b33a3adc67c29fcfdf5755c0a331297f0062 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Wed, 13 Dec 2023 13:05:24 -0500 Subject: [PATCH 04/55] 18652: EvaluableNodeReference can now return immediate values --- src/Amalgam/evaluablenode/EvaluableNode.h | 9 ++- .../evaluablenode/EvaluableNodeManagement.h | 78 ++++++++++++++----- 2 files changed, 63 insertions(+), 24 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index f038a0df..e4101298 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -915,7 +915,7 @@ class EvaluableNode // concrete values can be stored for the EvaluableNode. It is intended to // group types into the highest specificity that it is worth using to // compare two values based on their collective types -enum EvaluableNodeImmediateValueType +enum EvaluableNodeImmediateValueType : uint8_t { ENIVT_NOT_EXIST, //there is nothing to even hold the data ENIVT_NULL, //no data being held @@ -949,9 +949,10 @@ union EvaluableNodeImmediateValue : code(eniv.code) { } - constexpr EvaluableNodeImmediateValue &operator =(const EvaluableNodeImmediateValue &eniv) + __forceinline EvaluableNodeImmediateValue &operator =(const EvaluableNodeImmediateValue &eniv) { - code = eniv.code; + //perform a memcpy because it's a union, to be safe; the compiler should optimize this out + std::memcpy(this, &eniv, sizeof(this)); return *this; } @@ -1044,7 +1045,7 @@ class EvaluableNodeImmediateValueWithType : nodeType(enimvwt.nodeType), nodeValue(enimvwt.nodeValue) { } - constexpr EvaluableNodeImmediateValueWithType &operator =(const EvaluableNodeImmediateValueWithType &enimvwt) + __forceinline EvaluableNodeImmediateValueWithType &operator =(const EvaluableNodeImmediateValueWithType &enimvwt) { nodeType = enimvwt.nodeType; nodeValue = enimvwt.nodeValue; diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index 3a438f81..9be6a45c 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -11,54 +11,55 @@ typedef int32_t ExecutionCycleCountCompactDelta; class EvaluableNodeReference { public: - constexpr EvaluableNodeReference() : reference(nullptr), unique(true) + constexpr EvaluableNodeReference() + : referenceAndImmediate(nullptr), unique(true), immediate(false) { } constexpr EvaluableNodeReference(EvaluableNode *_reference, bool _unique) - : reference(_reference), unique(_unique) + : referenceAndImmediate(_reference), unique(_unique), immediate(false) { } - constexpr EvaluableNodeReference(const EvaluableNodeReference &inr) - : reference(inr.reference), unique(inr.unique) + __forceinline EvaluableNodeReference(const EvaluableNodeReference &inr) + : referenceAndImmediate(inr.referenceAndImmediate), unique(inr.unique), immediate(inr.immediate) { } //when attached a child node, make sure that this node reflects the same properties void UpdatePropertiesBasedOnAttachedNode(EvaluableNodeReference &attached) { - if(attached.reference == nullptr) + if(attached.referenceAndImmediate.reference == nullptr) return; if(!attached.unique) { unique = false; //if new attachments aren't unique, then can't guarantee there isn't a cycle present - reference->SetNeedCycleCheck(true); + referenceAndImmediate.reference->SetNeedCycleCheck(true); } - else if(attached.reference->GetNeedCycleCheck()) + else if(attached.referenceAndImmediate.reference->GetNeedCycleCheck()) { - reference->SetNeedCycleCheck(true); + referenceAndImmediate.reference->SetNeedCycleCheck(true); } - if(!attached.reference->GetIsIdempotent()) - reference->SetIsIdempotent(false); + if(!attached.referenceAndImmediate.reference->GetIsIdempotent()) + referenceAndImmediate.reference->SetIsIdempotent(false); } //calls GetNeedCycleCheck if the reference is not nullptr, returns false if it is nullptr constexpr bool GetNeedCycleCheck() { - if(reference == nullptr) + if(referenceAndImmediate.reference == nullptr) return false; - return reference->GetNeedCycleCheck(); + return referenceAndImmediate.reference->GetNeedCycleCheck(); } //calls SetNeedCycleCheck if the reference is not nullptr constexpr void SetNeedCycleCheck(bool need_cycle_check) { - if(reference == nullptr) + if(referenceAndImmediate.reference == nullptr) return; - reference->SetNeedCycleCheck(need_cycle_check); + referenceAndImmediate.reference->SetNeedCycleCheck(need_cycle_check); } constexpr static EvaluableNodeReference Null() @@ -68,34 +69,71 @@ class EvaluableNodeReference inline void SetReference(EvaluableNode *_reference) { - reference = _reference; + referenceAndImmediate.reference = _reference; } inline void SetReference(EvaluableNode *_reference, bool _unique) { - reference = _reference; + referenceAndImmediate.reference = _reference; unique = _unique; } inline EvaluableNode *&GetReference() { - return reference; + return referenceAndImmediate.reference; } //allow to use as an EvaluableNode * constexpr operator EvaluableNode *&() - { return reference; } + { return referenceAndImmediate.reference; } //allow to use as an EvaluableNode * constexpr EvaluableNode *operator->() - { return reference; } + { return referenceAndImmediate.reference; } + + __forceinline EvaluableNodeReference &operator =(const EvaluableNodeReference &enr) + { + //perform a memcpy because it's a union, to be safe; the compiler should optimize this out + std::memcpy(&referenceAndImmediate, &enr.referenceAndImmediate, sizeof(referenceAndImmediate)); + unique = enr.unique; + immediate = enr.immediate; + + return *this; + } protected: - EvaluableNode *reference; + + //efficient way to handle whether an InterpretNode method + // is returning an immediate value based on the immediate attribute + union ReferenceAndImmediate + { + constexpr ReferenceAndImmediate() + : reference(nullptr) + { } + + constexpr ReferenceAndImmediate(EvaluableNode *_reference) + : reference(_reference) + { } + + __forceinline ReferenceAndImmediate(const ReferenceAndImmediate &rai) + { + //perform a memcpy because it's a union, to be safe; the compiler should optimize this out + std::memcpy(this, &rai, sizeof(this)); + } + + EvaluableNode *reference; + EvaluableNodeImmediateValue immediate; + } referenceAndImmediate; + public: //this is the only reference to the result bool unique; + + //if immediate, then the storage is immediate + bool immediate; + + EvaluableNodeImmediateValueType immediateType; }; From a8d0dcd3a49d9b4921774bb84595d5f00ead6711 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Wed, 13 Dec 2023 13:11:37 -0500 Subject: [PATCH 05/55] 18652: Removes unnecessary overhead layer --- .../evaluablenode/EvaluableNodeManagement.h | 72 ++++++------------- 1 file changed, 23 insertions(+), 49 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index 9be6a45c..eb8faf37 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -12,54 +12,54 @@ class EvaluableNodeReference { public: constexpr EvaluableNodeReference() - : referenceAndImmediate(nullptr), unique(true), immediate(false) + : value(nullptr), unique(true) { } constexpr EvaluableNodeReference(EvaluableNode *_reference, bool _unique) - : referenceAndImmediate(_reference), unique(_unique), immediate(false) + : value(_reference), unique(_unique) { } __forceinline EvaluableNodeReference(const EvaluableNodeReference &inr) - : referenceAndImmediate(inr.referenceAndImmediate), unique(inr.unique), immediate(inr.immediate) + : value(inr.value), unique(inr.unique) { } //when attached a child node, make sure that this node reflects the same properties void UpdatePropertiesBasedOnAttachedNode(EvaluableNodeReference &attached) { - if(attached.referenceAndImmediate.reference == nullptr) + if(attached.value.nodeValue.code == nullptr) return; if(!attached.unique) { unique = false; //if new attachments aren't unique, then can't guarantee there isn't a cycle present - referenceAndImmediate.reference->SetNeedCycleCheck(true); + value.nodeValue.code->SetNeedCycleCheck(true); } - else if(attached.referenceAndImmediate.reference->GetNeedCycleCheck()) + else if(attached.value.nodeValue.code->GetNeedCycleCheck()) { - referenceAndImmediate.reference->SetNeedCycleCheck(true); + value.nodeValue.code->SetNeedCycleCheck(true); } - if(!attached.referenceAndImmediate.reference->GetIsIdempotent()) - referenceAndImmediate.reference->SetIsIdempotent(false); + if(!attached.value.nodeValue.code->GetIsIdempotent()) + value.nodeValue.code->SetIsIdempotent(false); } //calls GetNeedCycleCheck if the reference is not nullptr, returns false if it is nullptr constexpr bool GetNeedCycleCheck() { - if(referenceAndImmediate.reference == nullptr) + if(value.nodeValue.code == nullptr) return false; - return referenceAndImmediate.reference->GetNeedCycleCheck(); + return value.nodeValue.code->GetNeedCycleCheck(); } //calls SetNeedCycleCheck if the reference is not nullptr constexpr void SetNeedCycleCheck(bool need_cycle_check) { - if(referenceAndImmediate.reference == nullptr) + if(value.nodeValue.code == nullptr) return; - referenceAndImmediate.reference->SetNeedCycleCheck(need_cycle_check); + value.nodeValue.code->SetNeedCycleCheck(need_cycle_check); } constexpr static EvaluableNodeReference Null() @@ -67,73 +67,47 @@ class EvaluableNodeReference return EvaluableNodeReference(nullptr, true); } - inline void SetReference(EvaluableNode *_reference) + __forceinline void SetReference(EvaluableNode *_reference) { - referenceAndImmediate.reference = _reference; + value = _reference; } - inline void SetReference(EvaluableNode *_reference, bool _unique) + __forceinline void SetReference(EvaluableNode *_reference, bool _unique) { - referenceAndImmediate.reference = _reference; + value = _reference; unique = _unique; } - inline EvaluableNode *&GetReference() + constexpr EvaluableNode *&GetReference() { - return referenceAndImmediate.reference; + return value.nodeValue.code; } //allow to use as an EvaluableNode * constexpr operator EvaluableNode *&() - { return referenceAndImmediate.reference; } + { return value.nodeValue.code; } //allow to use as an EvaluableNode * constexpr EvaluableNode *operator->() - { return referenceAndImmediate.reference; } + { return value.nodeValue.code; } __forceinline EvaluableNodeReference &operator =(const EvaluableNodeReference &enr) { //perform a memcpy because it's a union, to be safe; the compiler should optimize this out - std::memcpy(&referenceAndImmediate, &enr.referenceAndImmediate, sizeof(referenceAndImmediate)); + value = enr.value; unique = enr.unique; - immediate = enr.immediate; return *this; } protected: - //efficient way to handle whether an InterpretNode method - // is returning an immediate value based on the immediate attribute - union ReferenceAndImmediate - { - constexpr ReferenceAndImmediate() - : reference(nullptr) - { } - - constexpr ReferenceAndImmediate(EvaluableNode *_reference) - : reference(_reference) - { } - - __forceinline ReferenceAndImmediate(const ReferenceAndImmediate &rai) - { - //perform a memcpy because it's a union, to be safe; the compiler should optimize this out - std::memcpy(this, &rai, sizeof(this)); - } - - EvaluableNode *reference; - EvaluableNodeImmediateValue immediate; - } referenceAndImmediate; + EvaluableNodeImmediateValueWithType value; public: //this is the only reference to the result bool unique; - - //if immediate, then the storage is immediate - bool immediate; - - EvaluableNodeImmediateValueType immediateType; }; From 576284002204942f5466f1c59a3f3e9c4ca6cad3 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Wed, 13 Dec 2023 13:31:57 -0500 Subject: [PATCH 06/55] 18652: Begins implementation of immediate value return types --- src/Amalgam/evaluablenode/EvaluableNode.h | 23 +++++++++++++++++++ .../evaluablenode/EvaluableNodeManagement.h | 18 ++++++++++++--- src/Amalgam/interpreter/Interpreter.cpp | 8 ++++--- src/Amalgam/interpreter/Interpreter.h | 4 ++-- 4 files changed, 45 insertions(+), 8 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index e4101298..e5f5ab96 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1088,6 +1088,29 @@ class EvaluableNodeImmediateValueWithType nodeValue = EvaluableNodeImmediateValue(en); } + double GetValueAsNumber(double value_if_null = std::numeric_limits::quiet_NaN()) + { + if(nodeType == ENIVT_NUMBER) + return nodeValue.number; + + if(nodeType == ENIVT_STRING_ID) + { + if(nodeValue.stringID == string_intern_pool.NOT_A_STRING_ID) + return value_if_null; + const auto &str = string_intern_pool.GetStringFromID(nodeValue.stringID); + auto [value, success] = Platform_StringToNumber(str); + if(success) + return value; + return value_if_null; + } + + if(nodeType == ENIVT_CODE) + return EvaluableNode::ToNumber(nodeValue.code); + + //nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX + return value_if_null; + } + static inline bool AreEqual(EvaluableNodeImmediateValueWithType &a, EvaluableNodeImmediateValueWithType &b) { return EvaluableNodeImmediateValue::AreEqual(a.nodeType, a.nodeValue, b.nodeType, b.nodeValue); diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index eb8faf37..aa307f5d 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -7,7 +7,9 @@ typedef int64_t ExecutionCycleCount; typedef int32_t ExecutionCycleCountCompactDelta; -//describes an EvaluableNode reference and whether it is uniquely referenced +//describes an EvaluableNode value and whether it is uniquely referenced +//this is mostly used for actual EvaluableNode *'s, and so most of the methods are built as such +//however, if it may contain an immediate value, then that must be checked via class EvaluableNodeReference { public: @@ -78,6 +80,16 @@ class EvaluableNodeReference unique = _unique; } + constexpr bool IsImmediateValue() + { + return value.nodeType != ENIVT_CODE; + } + + constexpr EvaluableNodeImmediateValueWithType &GetValue() + { + return value; + } + constexpr EvaluableNode *&GetReference() { return value.nodeValue.code; @@ -428,7 +440,7 @@ class EvaluableNodeManager //attempts to free the node reference __forceinline void FreeNodeIfPossible(EvaluableNodeReference &enr) { - if(enr.unique) + if(enr.unique && !enr.IsImmediateValue()) FreeNode(enr); } @@ -466,7 +478,7 @@ class EvaluableNodeManager //attempts to free the node reference __forceinline void FreeNodeTreeIfPossible(EvaluableNodeReference &enr) { - if(enr.unique) + if(enr.unique && !enr.IsImmediateValue()) FreeNodeTree(enr); } diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index f9eea3a0..c241d67f 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -642,11 +642,13 @@ double Interpreter::InterpretNodeIntoNumberValue(EvaluableNode *n) if(type == ENT_NUMBER) return n->GetNumberValueReference(); - auto result = InterpretNodeForImmediateUse(n); - double result_value = EvaluableNode::ToNumber(result); + auto result = InterpretNodeForImmediateUse(n, true); + auto &result_value = result.GetValue(); + + double value = result_value.GetValueAsNumber(); evaluableNodeManager->FreeNodeTreeIfPossible(result); - return result_value; + return value; } EvaluableNode *Interpreter::InterpretNodeIntoUniqueNumberValueEvaluableNode(EvaluableNode *n) diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index feb91d00..ed96e081 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -296,11 +296,11 @@ class Interpreter EvaluableNode *GetCurrentExecutionContext(); //if n is immediate, it just returns it, otherwise calls InterpretNode - __forceinline EvaluableNodeReference InterpretNodeForImmediateUse(EvaluableNode *n) + __forceinline EvaluableNodeReference InterpretNodeForImmediateUse(EvaluableNode *n, bool immediate_result = false) { if(n == nullptr || n->GetIsIdempotent()) return EvaluableNodeReference(n, false); - return InterpretNode(n); + return InterpretNode(n, immediate_result); } //Calls InterpretNode on n, converts to std::string and stores in value to return, then cleans up any resources used From c7a6672bc61a93f2af536ceae5c7f515fcacf6e0 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Wed, 13 Dec 2023 13:47:32 -0500 Subject: [PATCH 07/55] 18652: Begins implementing immediate return values --- .../evaluablenode/EvaluableNodeManagement.h | 10 ++- src/Amalgam/interpreter/Interpreter.cpp | 10 +++ .../interpreter/InterpreterOpcodesMath.cpp | 75 ++++++++++++++++--- 3 files changed, 82 insertions(+), 13 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index aa307f5d..52882b93 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -21,10 +21,18 @@ class EvaluableNodeReference : value(_reference), unique(_unique) { } - __forceinline EvaluableNodeReference(const EvaluableNodeReference &inr) + constexpr EvaluableNodeReference(const EvaluableNodeReference &inr) : value(inr.value), unique(inr.unique) { } + constexpr EvaluableNodeReference(double value) + : value(value), unique(true) + { } + + constexpr EvaluableNodeReference(StringInternPool::StringID string_id) + : value(string_id), unique(true) + { } + //when attached a child node, make sure that this node reflects the same properties void UpdatePropertiesBasedOnAttachedNode(EvaluableNodeReference &attached) { diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index c241d67f..7047aea8 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -542,6 +542,8 @@ std::pair Interpreter::InterpretNodeIntoStringValue(Evaluable if(n->GetType() == ENT_STRING) return std::make_pair(true, n->GetStringValue()); + //TODO 18652: implement special paths for this + auto result = InterpretNodeForImmediateUse(n); std::string result_string = EvaluableNode::ToString(result); evaluableNodeManager->FreeNodeTreeIfPossible(result); @@ -558,6 +560,8 @@ std::string Interpreter::InterpretNodeIntoStringValueEmptyNull(EvaluableNode *n) if(n->GetType() == ENT_STRING) return n->GetStringValue(); + //TODO 18652: implement special paths for this + auto result = InterpretNodeForImmediateUse(n); if(EvaluableNode::IsEmptyNode(result)) @@ -575,6 +579,8 @@ StringInternPool::StringID Interpreter::InterpretNodeIntoStringIDValueIfExists(E if(n != nullptr && n->GetType() == ENT_STRING) return n->GetStringID(); + //TODO 18652: implement special paths for this + auto result = InterpretNodeForImmediateUse(n); StringInternPool::StringID result_sid = EvaluableNode::ToStringIDIfExists(result); evaluableNodeManager->FreeNodeTreeIfPossible(result); @@ -588,6 +594,8 @@ StringInternPool::StringID Interpreter::InterpretNodeIntoStringIDValueWithRefere if(n != nullptr && n->GetType() == ENT_STRING) return string_intern_pool.CreateStringReference(n->GetStringID()); + //TODO 18652: implement special paths for this + auto result = InterpretNodeForImmediateUse(n); StringInternPool::StringID result_sid = string_intern_pool.NOT_A_STRING_ID; @@ -675,6 +683,8 @@ bool Interpreter::InterpretNodeIntoBoolValue(EvaluableNode *n, bool value_if_nul if(n == nullptr) return value_if_null; + //TODO 18652: implement special paths for this + auto result = InterpretNodeForImmediateUse(n); bool result_value = value_if_null; if(!EvaluableNode::IsNull(result)) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp index 934e865c..397c8a80 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp @@ -36,14 +36,20 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ADD(EvaluableNode *en, boo for(auto &cn : interpreted_nodes) value += EvaluableNode::ToNumber(cn); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + if(immediate_result) + return EvaluableNodeReference(value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } #endif for(auto &cn : ocn) value += InterpretNodeIntoNumberValue(cn); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + if(immediate_result) + return EvaluableNodeReference(value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en, bool immediate_result) @@ -61,7 +67,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en for(size_t i = 1; i < ocn.size(); i++) value -= EvaluableNode::ToNumber(interpreted_nodes[i]); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + if(immediate_result) + return EvaluableNodeReference(value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } #endif @@ -73,7 +82,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en if(ocn.size() == 1) value = -value; - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + if(immediate_result) + return EvaluableNodeReference(value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } EvaluableNodeReference Interpreter::InterpretNode_ENT_MULTIPLY(EvaluableNode *en, bool immediate_result) @@ -92,14 +104,20 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MULTIPLY(EvaluableNode *en for(auto &cn : interpreted_nodes) value *= EvaluableNode::ToNumber(cn); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + if(immediate_result) + return EvaluableNodeReference(value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } #endif for(auto &cn : ocn) value *= InterpretNodeIntoNumberValue(cn); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + if(immediate_result) + return EvaluableNodeReference(value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en, bool immediate_result) @@ -133,7 +151,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en, } } - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + if(immediate_result) + return EvaluableNodeReference(value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } #endif @@ -157,7 +178,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en, } } - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + if(immediate_result) + return EvaluableNodeReference(value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } EvaluableNodeReference Interpreter::InterpretNode_ENT_MODULUS(EvaluableNode *en, bool immediate_result) @@ -178,7 +202,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MODULUS(EvaluableNode *en, value = std::fmod(value, mod); } - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + if(immediate_result) + return EvaluableNodeReference(value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } #endif @@ -189,7 +216,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MODULUS(EvaluableNode *en, value = std::fmod(value, mod); } - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + if(immediate_result) + return EvaluableNodeReference(value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } //helper method for InterpretNode_ENT_GET_DIGITS and InterpretNode_ENT_SET_DIGITS @@ -353,7 +383,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_DIGITS(EvaluableNode * digits = InterpretNodeForImmediateUse(ocn[2]); if(digits == nullptr || digits->GetType() != ENT_LIST) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + { + if(immediate_result) + return EvaluableNodeReference(value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + } bool negative = (value < 0); if(negative) @@ -433,7 +468,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_DIGITS(EvaluableNode * if(negative) result_value = -result_value; - return EvaluableNodeReference(evaluableNodeManager->AllocNode(result_value), true); + if(immediate_result) + return EvaluableNodeReference(result_value); + else + return EvaluableNodeReference(evaluableNodeManager->AllocNode(result_value), true); } EvaluableNodeReference Interpreter::InterpretNode_ENT_FLOOR(EvaluableNode *en, bool immediate_result) @@ -443,6 +481,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FLOOR(EvaluableNode *en, b if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::floor(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::floor(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -455,6 +499,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CEILING(EvaluableNode *en, if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::ceil(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::ceil(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -468,6 +518,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en, b if(num_params == 0) return EvaluableNodeReference::Null(); + //TODO 18652: revisit this method downward EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); double number_value = retval->GetNumberValueReference(); From ca6566c5a75acebf027e5fabf1d86a3c0b6ebb91 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Wed, 13 Dec 2023 14:17:09 -0500 Subject: [PATCH 08/55] 18652: More immediate implementation --- src/Amalgam/interpreter/Interpreter.h | 8 + .../interpreter/InterpreterOpcodesMath.cpp | 251 ++++++++++++------ 2 files changed, 176 insertions(+), 83 deletions(-) diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index ed96e081..ed3334a1 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -295,6 +295,14 @@ class Interpreter //returns the current execution context, nullptr if none EvaluableNode *GetCurrentExecutionContext(); + //returns an EvaluableNodeReference for value, allocating if necessary based on if immediate result is needed + inline EvaluableNodeReference AllocNumberReturn(double value, bool immediate_result) + { + if(immediate_result) + return EvaluableNodeReference(value); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + } + //if n is immediate, it just returns it, otherwise calls InterpretNode __forceinline EvaluableNodeReference InterpretNodeForImmediateUse(EvaluableNode *n, bool immediate_result = false) { diff --git a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp index 397c8a80..b9645f88 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp @@ -23,7 +23,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ADD(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); @@ -36,26 +35,19 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ADD(EvaluableNode *en, boo for(auto &cn : interpreted_nodes) value += EvaluableNode::ToNumber(cn); - if(immediate_result) - return EvaluableNodeReference(value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocNumberReturn(value, immediate_result); } #endif for(auto &cn : ocn) value += InterpretNodeIntoNumberValue(cn); - if(immediate_result) - return EvaluableNodeReference(value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocNumberReturn(value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); @@ -67,10 +59,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en for(size_t i = 1; i < ocn.size(); i++) value -= EvaluableNode::ToNumber(interpreted_nodes[i]); - if(immediate_result) - return EvaluableNodeReference(value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocNumberReturn(value, immediate_result); } #endif @@ -82,16 +71,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en if(ocn.size() == 1) value = -value; - if(immediate_result) - return EvaluableNodeReference(value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocNumberReturn(value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_MULTIPLY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); @@ -104,26 +89,19 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MULTIPLY(EvaluableNode *en for(auto &cn : interpreted_nodes) value *= EvaluableNode::ToNumber(cn); - if(immediate_result) - return EvaluableNodeReference(value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocNumberReturn(value, immediate_result); } #endif for(auto &cn : ocn) value *= InterpretNodeIntoNumberValue(cn); - if(immediate_result) - return EvaluableNodeReference(value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocNumberReturn(value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); @@ -151,10 +129,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en, } } - if(immediate_result) - return EvaluableNodeReference(value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocNumberReturn(value, immediate_result); } #endif @@ -178,16 +153,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en, } } - if(immediate_result) - return EvaluableNodeReference(value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocNumberReturn(value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_MODULUS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); @@ -202,10 +173,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MODULUS(EvaluableNode *en, value = std::fmod(value, mod); } - if(immediate_result) - return EvaluableNodeReference(value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocNumberReturn(value, immediate_result); } #endif @@ -216,10 +184,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MODULUS(EvaluableNode *en, value = std::fmod(value, mod); } - if(immediate_result) - return EvaluableNodeReference(value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocNumberReturn(value, immediate_result); } //helper method for InterpretNode_ENT_GET_DIGITS and InterpretNode_ENT_SET_DIGITS @@ -383,12 +348,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_DIGITS(EvaluableNode * digits = InterpretNodeForImmediateUse(ocn[2]); if(digits == nullptr || digits->GetType() != ENT_LIST) - { - if(immediate_result) - return EvaluableNodeReference(value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); - } + return AllocNumberReturn(value, immediate_result); bool negative = (value < 0); if(negative) @@ -468,16 +428,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_DIGITS(EvaluableNode * if(negative) result_value = -result_value; - if(immediate_result) - return EvaluableNodeReference(result_value); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(result_value), true); + return AllocNumberReturn(result_value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_FLOOR(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); @@ -495,7 +451,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FLOOR(EvaluableNode *en, b EvaluableNodeReference Interpreter::InterpretNode_ENT_CEILING(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); @@ -513,19 +468,27 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CEILING(EvaluableNode *en, EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - size_t num_params = ocn.size(); if(num_params == 0) return EvaluableNodeReference::Null(); - //TODO 18652: revisit this method downward - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - double number_value = retval->GetNumberValueReference(); + EvaluableNodeReference retval; + double number_value = 0.0; + + if(immediate_result) + { + number_value = InterpretNodeIntoNumberValue(ocn[0]); + } + else + { + retval = EvaluableNodeReference(InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]), true); + number_value = retval->GetNumberValueReference(); + } if(num_params == 1) { //just round to the nearest integer - retval->SetNumberValue(std::round(number_value)); + number_value = std::round(number_value); } else { @@ -547,20 +510,29 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en, b num_significant_digits = std::min(starting_significant_digit + num_digits_after_decimal, num_significant_digits); double factor = std::pow(10.0, num_significant_digits - starting_significant_digit); - retval->SetNumberValue(std::round(number_value * factor) / factor); + number_value = std::round(number_value * factor) / factor; } } - return EvaluableNodeReference(retval, true); + if(immediate_result) + return EvaluableNodeReference(number_value); + + retval->SetNumberValue(number_value); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_EXPONENT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::exp(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::exp(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -569,7 +541,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EXPONENT(EvaluableNode *en EvaluableNodeReference Interpreter::InterpretNode_ENT_LOG(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); @@ -580,6 +551,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LOG(EvaluableNode *en, boo divisor = log(log_base); } + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::log(value) / divisor); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::log(retval->GetNumberValueReference()) / divisor); return EvaluableNodeReference(retval, true); @@ -588,10 +565,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LOG(EvaluableNode *en, boo EvaluableNodeReference Interpreter::InterpretNode_ENT_SIN(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::sin(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::sin(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -600,10 +582,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SIN(EvaluableNode *en, boo EvaluableNodeReference Interpreter::InterpretNode_ENT_ASIN(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::asin(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::asin(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -612,10 +599,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASIN(EvaluableNode *en, bo EvaluableNodeReference Interpreter::InterpretNode_ENT_COS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::cos(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::cos(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -624,10 +616,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COS(EvaluableNode *en, boo EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::acos(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::acos(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -636,10 +633,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOS(EvaluableNode *en, bo EvaluableNodeReference Interpreter::InterpretNode_ENT_TAN(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::tan(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::tan(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -654,6 +656,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ATAN(EvaluableNode *en, bo if(ocn.size() == 1) { + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::atan(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::atan(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -662,7 +670,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ATAN(EvaluableNode *en, bo { double f1 = InterpretNodeIntoNumberValue(ocn[0]); double f2 = InterpretNodeIntoNumberValue(ocn[1]); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(std::atan2(f1, f2)), true); + return AllocNumberReturn(std::atan2(f1, f2), immediate_result); } return EvaluableNodeReference::Null(); } @@ -670,10 +678,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ATAN(EvaluableNode *en, bo EvaluableNodeReference Interpreter::InterpretNode_ENT_SINH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::sinh(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::sinh(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -682,10 +695,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SINH(EvaluableNode *en, bo EvaluableNodeReference Interpreter::InterpretNode_ENT_ASINH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::asinh(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::asinh(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -694,10 +712,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASINH(EvaluableNode *en, b EvaluableNodeReference Interpreter::InterpretNode_ENT_COSH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::cosh(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::cosh(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -706,10 +729,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COSH(EvaluableNode *en, bo EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOSH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::acosh(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::acosh(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -718,10 +746,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOSH(EvaluableNode *en, b EvaluableNodeReference Interpreter::InterpretNode_ENT_TANH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::tanh(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::tanh(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -734,6 +767,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ATANH(EvaluableNode *en, b if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::atanh(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::atanh(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -742,10 +781,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ATANH(EvaluableNode *en, b EvaluableNodeReference Interpreter::InterpretNode_ENT_ERF(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::erf(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::erf(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -754,10 +798,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ERF(EvaluableNode *en, boo EvaluableNodeReference Interpreter::InterpretNode_ENT_TGAMMA(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::tgamma(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::tgamma(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -766,10 +815,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TGAMMA(EvaluableNode *en, EvaluableNodeReference Interpreter::InterpretNode_ENT_LGAMMA(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::lgamma(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::lgamma(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -778,10 +832,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LGAMMA(EvaluableNode *en, EvaluableNodeReference Interpreter::InterpretNode_ENT_SQRT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::sqrt(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::sqrt(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -796,16 +855,21 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_POW(EvaluableNode *en, boo double f1 = InterpretNodeIntoNumberValue(ocn[0]); double f2 = InterpretNodeIntoNumberValue(ocn[1]); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(std::pow(f1, f2)), true); + return AllocNumberReturn(std::pow(f1, f2), immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ABS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(ocn[0]); + return EvaluableNodeReference(std::abs(value)); + } + EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::abs(retval->GetNumberValueReference())); return EvaluableNodeReference(retval, true); @@ -1003,6 +1067,13 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DOT_PRODUCT(EvaluableNode } } + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(elements1); + evaluableNodeManager->FreeNodeTreeIfPossible(elements2); + return EvaluableNodeReference(dot_product); + } + EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocOneOfNodes(elements1, elements2, ENT_NUMBER); result->SetNumberValue(dot_product); return result; @@ -1175,6 +1246,13 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GENERALIZED_DISTANCE(Evalu double value = dist_params.ComputeMinkowskiDistance(location, location_types, origin, origin_types, true); + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(location_node); + evaluableNodeManager->FreeNodeTreeIfPossible(origin_node); + return EvaluableNodeReference(value); + } + //free these after computation in case they had any code being used/referenced in the distance EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocOneOfNodes(location_node, origin_node, ENT_NUMBER); result->SetNumberValue(value); @@ -1399,6 +1477,13 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ENTROPY(EvaluableNode *en, //we take the max of the result and 0 accumulated_entropy = std::max(0.0, accumulated_entropy); + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(p_node); + evaluableNodeManager->FreeNodeTreeIfPossible(q_node); + return EvaluableNodeReference(accumulated_entropy); + } + EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocOneOfNodes(p_node, q_node, ENT_NUMBER); result->SetNumberValue(accumulated_entropy); return result; From e995c42944f8182cb49ade524427e75d6f44b0a9 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Wed, 13 Dec 2023 14:21:57 -0500 Subject: [PATCH 09/55] 18652: Code cleanup --- src/Amalgam/interpreter/Interpreter.cpp | 6 +- src/Amalgam/interpreter/Interpreter.h | 2 +- .../interpreter/InterpreterOpcodesMath.cpp | 86 +++++++++---------- 3 files changed, 47 insertions(+), 47 deletions(-) diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index 7047aea8..59995dd7 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -659,15 +659,15 @@ double Interpreter::InterpretNodeIntoNumberValue(EvaluableNode *n) return value; } -EvaluableNode *Interpreter::InterpretNodeIntoUniqueNumberValueEvaluableNode(EvaluableNode *n) +EvaluableNodeReference Interpreter::InterpretNodeIntoUniqueNumberValueEvaluableNode(EvaluableNode *n) { if(n == nullptr || n->GetIsIdempotent()) - return evaluableNodeManager->AllocNode(EvaluableNode::ToNumber(n)); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(EvaluableNode::ToNumber(n)), true); auto result = InterpretNode(n); if(result == nullptr || !result.unique) - return evaluableNodeManager->AllocNode(EvaluableNode::ToNumber(result)); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(EvaluableNode::ToNumber(result)), true); result->ClearMetadata(); diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index ed3334a1..1c932e58 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -332,7 +332,7 @@ class Interpreter double InterpretNodeIntoNumberValue(EvaluableNode *n); //Calls InterpnetNode on n, convers to a double, and makes sure that the node returned is new and unique so that it can be modified - EvaluableNode *InterpretNodeIntoUniqueNumberValueEvaluableNode(EvaluableNode *n); + EvaluableNodeReference InterpretNodeIntoUniqueNumberValueEvaluableNode(EvaluableNode *n); //Calls InterpretNode on n, converts to boolean and returns, then cleans up any resources used bool InterpretNodeIntoBoolValue(EvaluableNode *n, bool value_if_null = false); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp index b9645f88..bb94c3cf 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp @@ -443,9 +443,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FLOOR(EvaluableNode *en, b return EvaluableNodeReference(std::floor(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::floor(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_CEILING(EvaluableNode *en, bool immediate_result) @@ -460,9 +460,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CEILING(EvaluableNode *en, return EvaluableNodeReference(std::ceil(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::ceil(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en, bool immediate_result) @@ -481,7 +481,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en, b } else { - retval = EvaluableNodeReference(InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]), true); + retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); number_value = retval->GetNumberValueReference(); } @@ -533,9 +533,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EXPONENT(EvaluableNode *en return EvaluableNodeReference(std::exp(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::exp(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_LOG(EvaluableNode *en, bool immediate_result) @@ -557,9 +557,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LOG(EvaluableNode *en, boo return EvaluableNodeReference(std::log(value) / divisor); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::log(retval->GetNumberValueReference()) / divisor); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_SIN(EvaluableNode *en, bool immediate_result) @@ -574,9 +574,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SIN(EvaluableNode *en, boo return EvaluableNodeReference(std::sin(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::sin(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_ASIN(EvaluableNode *en, bool immediate_result) @@ -591,9 +591,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASIN(EvaluableNode *en, bo return EvaluableNodeReference(std::asin(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::asin(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_COS(EvaluableNode *en, bool immediate_result) @@ -608,9 +608,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COS(EvaluableNode *en, boo return EvaluableNodeReference(std::cos(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::cos(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOS(EvaluableNode *en, bool immediate_result) @@ -625,9 +625,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOS(EvaluableNode *en, bo return EvaluableNodeReference(std::acos(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::acos(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_TAN(EvaluableNode *en, bool immediate_result) @@ -642,9 +642,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAN(EvaluableNode *en, boo return EvaluableNodeReference(std::tan(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::tan(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_ATAN(EvaluableNode *en, bool immediate_result) @@ -662,9 +662,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ATAN(EvaluableNode *en, bo return EvaluableNodeReference(std::atan(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::atan(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } else if(ocn.size() >= 2) { @@ -687,9 +687,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SINH(EvaluableNode *en, bo return EvaluableNodeReference(std::sinh(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::sinh(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_ASINH(EvaluableNode *en, bool immediate_result) @@ -704,9 +704,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASINH(EvaluableNode *en, b return EvaluableNodeReference(std::asinh(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::asinh(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_COSH(EvaluableNode *en, bool immediate_result) @@ -721,9 +721,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COSH(EvaluableNode *en, bo return EvaluableNodeReference(std::cosh(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::cosh(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOSH(EvaluableNode *en, bool immediate_result) @@ -738,9 +738,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOSH(EvaluableNode *en, b return EvaluableNodeReference(std::acosh(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::acosh(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_TANH(EvaluableNode *en, bool immediate_result) @@ -755,9 +755,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TANH(EvaluableNode *en, bo return EvaluableNodeReference(std::tanh(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::tanh(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_ATANH(EvaluableNode *en, bool immediate_result) @@ -773,9 +773,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ATANH(EvaluableNode *en, b return EvaluableNodeReference(std::atanh(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::atanh(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_ERF(EvaluableNode *en, bool immediate_result) @@ -790,9 +790,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ERF(EvaluableNode *en, boo return EvaluableNodeReference(std::erf(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::erf(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_TGAMMA(EvaluableNode *en, bool immediate_result) @@ -807,9 +807,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TGAMMA(EvaluableNode *en, return EvaluableNodeReference(std::tgamma(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::tgamma(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_LGAMMA(EvaluableNode *en, bool immediate_result) @@ -824,9 +824,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LGAMMA(EvaluableNode *en, return EvaluableNodeReference(std::lgamma(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::lgamma(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_SQRT(EvaluableNode *en, bool immediate_result) @@ -841,9 +841,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SQRT(EvaluableNode *en, bo return EvaluableNodeReference(std::sqrt(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::sqrt(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_POW(EvaluableNode *en, bool immediate_result) @@ -870,9 +870,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ABS(EvaluableNode *en, boo return EvaluableNodeReference(std::abs(value)); } - EvaluableNode *retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); retval->SetNumberValue(std::abs(retval->GetNumberValueReference())); - return EvaluableNodeReference(retval, true); + return retval; } EvaluableNodeReference Interpreter::InterpretNode_ENT_MAX(EvaluableNode *en, bool immediate_result) From 22ba863d525fce4d43b495aaf69bfdf7c65786b1 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Wed, 13 Dec 2023 14:26:36 -0500 Subject: [PATCH 10/55] 18652: Adds todos --- src/Amalgam/interpreter/Interpreter.cpp | 2 +- src/Amalgam/interpreter/InterpreterOpcodesBase.cpp | 2 ++ src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp | 2 ++ src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp | 2 ++ src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp | 2 ++ src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp | 2 ++ src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp | 2 ++ src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp | 2 ++ src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp | 2 ++ 9 files changed, 17 insertions(+), 1 deletion(-) diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index 59995dd7..9c501d7e 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -683,7 +683,7 @@ bool Interpreter::InterpretNodeIntoBoolValue(EvaluableNode *n, bool value_if_nul if(n == nullptr) return value_if_null; - //TODO 18652: implement special paths for this + //TODO 18652: implement special paths for this -- need new value(s) for EvaluableNodeImmediateValueType? auto result = InterpretNodeForImmediateUse(n); bool result_value = value_if_null; diff --git a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp index 94d2aa09..a828c33b 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp @@ -24,6 +24,8 @@ #include #include +//TODO 18652: evaluate InterpretNode_* for immediate returns + //Used only for deep debugging of entity memory and garbage collection std::string GetEntityMemorySizeDiagnostics(Entity *e) { diff --git a/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp b/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp index fbe94c64..dbf71032 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp @@ -19,6 +19,8 @@ #include #include +//TODO 18652: evaluate InterpretNode_* for immediate returns + EvaluableNodeReference Interpreter::InterpretNode_ENT_MUTATE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index 7ed88bc5..33e55f3a 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -26,6 +26,8 @@ #include #include +//TODO 18652: evaluate InterpretNode_* for immediate returns + EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUE(EvaluableNode *en, bool immediate_result) { return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp index 5454c5d9..11fc445b 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp @@ -22,6 +22,8 @@ #include #include +//TODO 18652: evaluate InterpretNode_* for immediate returns + EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_ENTITY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp index d7e5ec95..b7e35e5a 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp @@ -19,6 +19,8 @@ #include #include +//TODO 18652: evaluate InterpretNode_* for immediate returns + EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_COMMENTS(EvaluableNode *en, bool immediate_result) { if(curEntity == nullptr) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp index 8c83bd61..a7ecc75f 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp @@ -19,6 +19,8 @@ #include #include +//TODO 18652: evaluate InterpretNode_* for immediate returns + EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp index cf786e52..d658992b 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp @@ -19,6 +19,8 @@ #include #include +//TODO 18652: evaluate InterpretNode_* for immediate returns + EvaluableNodeReference Interpreter::InterpretNode_ENT_AND(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp index 599c854d..f7111501 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp @@ -19,6 +19,8 @@ #include #include +//TODO 18652: evaluate InterpretNode_* for immediate returns + EvaluableNodeReference Interpreter::InterpretNode_ENT_REWRITE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); From 72a09038ce29917d01494e7404b170599b5aec24 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Thu, 14 Dec 2023 21:30:13 -0500 Subject: [PATCH 11/55] 18652: Removes todo --- src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp b/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp index dbf71032..fbe94c64 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp @@ -19,8 +19,6 @@ #include #include -//TODO 18652: evaluate InterpretNode_* for immediate returns - EvaluableNodeReference Interpreter::InterpretNode_ENT_MUTATE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); From 144d83fab9104e8a915959f9705e1477bc740326 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Fri, 15 Dec 2023 20:55:47 -0500 Subject: [PATCH 12/55] 18652: More implementation --- src/Amalgam/evaluablenode/EvaluableNode.h | 28 +++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index e5f5ab96..91749888 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1097,6 +1097,7 @@ class EvaluableNodeImmediateValueWithType { if(nodeValue.stringID == string_intern_pool.NOT_A_STRING_ID) return value_if_null; + const auto &str = string_intern_pool.GetStringFromID(nodeValue.stringID); auto [value, success] = Platform_StringToNumber(str); if(success) @@ -1111,6 +1112,33 @@ class EvaluableNodeImmediateValueWithType return value_if_null; } + std::pair GetValueAsString() + { + //TODO 18652: make sure if type is ENIVT_CODE, that the return values are handled the same as empty nodes in Interpreter::InterpretNodeInto* + if(nodeType == ENIVT_NUMBER) + { + if(FastIsNaN(nodeValue.number)) + return std::make_pair(false, ""); + + return std::make_pair(true, EvaluableNode::NumberToString(nodeValue.number)); + } + + if(nodeType == ENIVT_STRING_ID) + { + if(nodeValue.stringID == string_intern_pool.NOT_A_STRING_ID) + return std::make_pair(false, ""); + + const auto &str = string_intern_pool.GetStringFromID(nodeValue.stringID); + return std::make_pair(true, str); + } + + if(nodeType == ENIVT_CODE) + return std::make_pair(true, EvaluableNode::ToString(nodeValue.code)); + + //nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX + return std::make_pair(false, ""); + } + static inline bool AreEqual(EvaluableNodeImmediateValueWithType &a, EvaluableNodeImmediateValueWithType &b) { return EvaluableNodeImmediateValue::AreEqual(a.nodeType, a.nodeValue, b.nodeType, b.nodeValue); From 0a0c497fe49beb48290aed20d4add3f7d0171ba4 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Fri, 22 Dec 2023 18:21:17 -0500 Subject: [PATCH 13/55] 18652: More implementation --- src/Amalgam/evaluablenode/EvaluableNode.h | 3 +++ src/Amalgam/interpreter/Interpreter.cpp | 14 ++++---------- 2 files changed, 7 insertions(+), 10 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index be4e22a6..f809e36a 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1135,6 +1135,9 @@ class EvaluableNodeImmediateValueWithType return std::make_pair(true, str); } + if(nodeType == ENIVT_NULL) + return std::make_pair(false, ""); + if(nodeType == ENIVT_CODE) return std::make_pair(true, EvaluableNode::ToStringPreservingOpcodeType(nodeValue.code)); diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index e981de7b..235f2b61 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -542,19 +542,13 @@ std::pair Interpreter::InterpretNodeIntoStringValue(Evaluable if(n->GetType() == ENT_STRING) return std::make_pair(true, n->GetStringValue()); - //TODO 18652: implement special paths for this - - auto result = InterpretNodeForImmediateUse(n); - if(EvaluableNode::IsEmptyNode(n)) - { - evaluableNodeManager->FreeNodeTreeIfPossible(result); - return std::make_pair(false, ""); - } + auto result = InterpretNodeForImmediateUse(n, true); + auto &result_value = result.GetValue(); - std::string result_string = EvaluableNode::ToStringPreservingOpcodeType(result); + auto [valid, str] = result_value.GetValueAsString(); evaluableNodeManager->FreeNodeTreeIfPossible(result); - return std::make_pair(true, result_string); + return std::make_pair(valid, str); } std::string Interpreter::InterpretNodeIntoStringValueEmptyNull(EvaluableNode *n) From c56e6d8b1b7af544145c842d9cf1b2bfe22ce2e5 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Fri, 22 Dec 2023 18:25:28 -0500 Subject: [PATCH 14/55] 18652: Todo updates --- src/Amalgam/evaluablenode/EvaluableNode.h | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index f809e36a..fd6a4569 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1117,7 +1117,6 @@ class EvaluableNodeImmediateValueWithType std::pair GetValueAsString() { - //TODO 18652: make sure if type is ENIVT_CODE, that the return values are handled the same as empty nodes in Interpreter::InterpretNodeInto* if(nodeType == ENIVT_NUMBER) { if(FastIsNaN(nodeValue.number)) @@ -1145,6 +1144,18 @@ class EvaluableNodeImmediateValueWithType return std::make_pair(false, ""); } + StringInternPool::StringID GetValueAsStringIDIfExists() + { + //TODO 18652: implement this + return string_intern_pool.NOT_A_STRING_ID; + } + + StringInternPool::StringID GetValueAsStringIDWithReference() + { + //TODO 18652: implement this + return string_intern_pool.NOT_A_STRING_ID; + } + static inline bool AreEqual(EvaluableNodeImmediateValueWithType &a, EvaluableNodeImmediateValueWithType &b) { return EvaluableNodeImmediateValue::AreEqual(a.nodeType, a.nodeValue, b.nodeType, b.nodeValue); From 7c9bfd373a57f783d81dca3cbadbaa0ffc163b4e Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Fri, 22 Dec 2023 18:32:03 -0500 Subject: [PATCH 15/55] 18652: More implementation --- src/Amalgam/evaluablenode/EvaluableNode.h | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index fd6a4569..d7831e4b 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1134,9 +1134,6 @@ class EvaluableNodeImmediateValueWithType return std::make_pair(true, str); } - if(nodeType == ENIVT_NULL) - return std::make_pair(false, ""); - if(nodeType == ENIVT_CODE) return std::make_pair(true, EvaluableNode::ToStringPreservingOpcodeType(nodeValue.code)); @@ -1147,12 +1144,28 @@ class EvaluableNodeImmediateValueWithType StringInternPool::StringID GetValueAsStringIDIfExists() { //TODO 18652: implement this + if(nodeType == ENIVT_NUMBER) + { + + } + + if(nodeType == ENIVT_STRING_ID) + return nodeValue.stringID; + + if(nodeType == ENIVT_CODE) + { + + } + + //nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX return string_intern_pool.NOT_A_STRING_ID; } StringInternPool::StringID GetValueAsStringIDWithReference() { //TODO 18652: implement this + + //nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX return string_intern_pool.NOT_A_STRING_ID; } From ef4f636e5c407ae9732b31e5802c2bfe9add39f7 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Fri, 22 Dec 2023 23:07:54 -0500 Subject: [PATCH 16/55] 18652: More implementation --- src/Amalgam/interpreter/Interpreter.cpp | 22 ---------------------- src/Amalgam/interpreter/Interpreter.h | 8 +++++++- 2 files changed, 7 insertions(+), 23 deletions(-) diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index 235f2b61..ff1ac034 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -551,28 +551,6 @@ std::pair Interpreter::InterpretNodeIntoStringValue(Evaluable return std::make_pair(valid, str); } -std::string Interpreter::InterpretNodeIntoStringValueEmptyNull(EvaluableNode *n) -{ - if(EvaluableNode::IsEmptyNode(n)) - return ""; - - //shortcut if the node has what is being asked - if(n->GetType() == ENT_STRING) - return n->GetStringValue(); - - //TODO 18652: implement special paths for this - - auto result = InterpretNodeForImmediateUse(n); - - if(EvaluableNode::IsEmptyNode(result)) - return ""; - - std::string result_string = EvaluableNode::ToStringPreservingOpcodeType(result); - evaluableNodeManager->FreeNodeTreeIfPossible(result); - - return result_string; -} - StringInternPool::StringID Interpreter::InterpretNodeIntoStringIDValueIfExists(EvaluableNode *n) { //shortcut if the node has what is being asked diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index 1c932e58..bd2819d2 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -317,7 +317,13 @@ class Interpreter //Calls InterpretNode on n, converts to std::string and stores in value to return, then cleans up any resources used // but if n is null, it will return an empty string - std::string InterpretNodeIntoStringValueEmptyNull(EvaluableNode *n); + inline std::string InterpretNodeIntoStringValueEmptyNull(EvaluableNode *n) + { + auto [valid, str] = InterpretNodeIntoStringValue(n); + if(!valid) + return ""; + return str; + } //like InterpretNodeIntoStringValue, but returns the ID only if the string already exists, otherwise it returns NOT_A_STRING_ID StringInternPool::StringID InterpretNodeIntoStringIDValueIfExists(EvaluableNode *n); From f17aa72f0443f38e56316652c76a253f82deb731 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sat, 23 Dec 2023 10:37:56 -0500 Subject: [PATCH 17/55] 18652: Updates InterpretNodeIntoBoolValue --- src/Amalgam/evaluablenode/EvaluableNode.h | 41 +++++++++++++++++++++++ src/Amalgam/interpreter/Interpreter.cpp | 11 +++--- 2 files changed, 45 insertions(+), 7 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index d7831e4b..92bf2b81 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1032,6 +1032,19 @@ class EvaluableNodeImmediateValueWithType : nodeType(ENIVT_NULL) { } + __forceinline EvaluableNodeImmediateValueWithType(bool value) + { + if(value) + { + nodeType = ENIVT_NUMBER; + nodeValue.number = 1.0; + } + else + { + nodeType = ENIVT_NULL; + } + } + constexpr EvaluableNodeImmediateValueWithType(double number) : nodeType(ENIVT_NUMBER), nodeValue(number) { } @@ -1091,6 +1104,34 @@ class EvaluableNodeImmediateValueWithType nodeValue = EvaluableNodeImmediateValue(en); } + bool GetValueAsBoolean() + { + if(nodeType == ENIVT_NULL) + return false; + + if(nodeType == ENIVT_NUMBER) + { + if(nodeValue.number == 0.0) + return false; + if(FastIsNaN(nodeValue.number)) + return false; + return true; + } + + if(nodeType == ENIVT_STRING_ID) + { + if(nodeValue.stringID <= StringInternPool::EMPTY_STRING_ID) + return false; + return true; + } + + if(nodeType == ENIVT_CODE) + return EvaluableNode::IsTrue(nodeValue.code); + + //nodeType is one of ENIVT_NOT_EXIST, ENIVT_NUMBER_INDIRECTION_INDEX + return false; + } + double GetValueAsNumber(double value_if_null = std::numeric_limits::quiet_NaN()) { if(nodeType == ENIVT_NUMBER) diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index ff1ac034..446a9d17 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -661,16 +661,13 @@ bool Interpreter::InterpretNodeIntoBoolValue(EvaluableNode *n, bool value_if_nul if(n == nullptr) return value_if_null; - //TODO 18652: implement special paths for this -- need new value(s) for EvaluableNodeImmediateValueType? - - auto result = InterpretNodeForImmediateUse(n); - bool result_value = value_if_null; - if(!EvaluableNode::IsNull(result)) - result_value = EvaluableNode::IsTrue(result); + auto result = InterpretNodeForImmediateUse(n, true); + auto &result_value = result.GetValue(); + bool value = result_value.GetValueAsBoolean(); evaluableNodeManager->FreeNodeTreeIfPossible(result); - return result_value; + return value; } void Interpreter::InterpretNodeIntoDestinationEntity(EvaluableNode *n, Entity *&destination_entity_parent, StringInternRef &new_entity_id) From ccad4faf9053419c9ae117b967682071b0827d8a Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sat, 23 Dec 2023 11:21:24 -0500 Subject: [PATCH 18/55] 18652: More implementation --- src/Amalgam/evaluablenode/EvaluableNode.h | 27 ++++++++++++++++++----- src/Amalgam/interpreter/Interpreter.cpp | 10 ++++----- 2 files changed, 26 insertions(+), 11 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index 92bf2b81..53d0dae6 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1184,19 +1184,21 @@ class EvaluableNodeImmediateValueWithType StringInternPool::StringID GetValueAsStringIDIfExists() { - //TODO 18652: implement this if(nodeType == ENIVT_NUMBER) { - + if(FastIsNaN(nodeValue.number)) + return StringInternPool::NOT_A_STRING_ID; + + const std::string str_value = EvaluableNode::NumberToString(nodeValue.number); + //will return empty string if not found + return string_intern_pool.GetIDFromString(str_value); } if(nodeType == ENIVT_STRING_ID) return nodeValue.stringID; if(nodeType == ENIVT_CODE) - { - - } + return EvaluableNode::ToStringIDIfExists(nodeValue.code); //nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX return string_intern_pool.NOT_A_STRING_ID; @@ -1204,7 +1206,20 @@ class EvaluableNodeImmediateValueWithType StringInternPool::StringID GetValueAsStringIDWithReference() { - //TODO 18652: implement this + if(nodeType == ENIVT_NUMBER) + { + if(FastIsNaN(nodeValue.number)) + return StringInternPool::NOT_A_STRING_ID; + + const std::string str_value = EvaluableNode::NumberToString(nodeValue.number); + return string_intern_pool.CreateStringReference(str_value); + } + + if(nodeType == ENIVT_STRING_ID) + return string_intern_pool.CreateStringReference(nodeValue.stringID); + + if(nodeType == ENIVT_CODE) + return EvaluableNode::ToStringIDWithReference(nodeValue.code); //nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX return string_intern_pool.NOT_A_STRING_ID; diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index 446a9d17..8589d028 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -557,13 +557,13 @@ StringInternPool::StringID Interpreter::InterpretNodeIntoStringIDValueIfExists(E if(n != nullptr && n->GetType() == ENT_STRING) return n->GetStringID(); - //TODO 18652: implement special paths for this + auto result = InterpretNodeForImmediateUse(n, true); + auto &result_value = result.GetValue(); - auto result = InterpretNodeForImmediateUse(n); - StringInternPool::StringID result_sid = EvaluableNode::ToStringIDIfExists(result); + auto sid = result_value.GetValueAsStringIDIfExists(); evaluableNodeManager->FreeNodeTreeIfPossible(result); - return result_sid; + return sid; } StringInternPool::StringID Interpreter::InterpretNodeIntoStringIDValueWithReference(EvaluableNode *n) @@ -572,7 +572,7 @@ StringInternPool::StringID Interpreter::InterpretNodeIntoStringIDValueWithRefere if(n != nullptr && n->GetType() == ENT_STRING) return string_intern_pool.CreateStringReference(n->GetStringID()); - //TODO 18652: implement special paths for this + //TODO 18652: implement special paths for this -- need to balance extra overhead for methods that don't return immediates auto result = InterpretNodeForImmediateUse(n); From 53acd93433fe54f508af5daa690a06b31de0ebb6 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sat, 23 Dec 2023 12:39:53 -0500 Subject: [PATCH 19/55] 18652: More implementation --- .../evaluablenode/EvaluableNodeManagement.h | 4 ++++ .../InterpreterOpcodesTransformations.cpp | 22 +++++++++++++------ 2 files changed, 19 insertions(+), 7 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index 52882b93..f81de19c 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -25,6 +25,10 @@ class EvaluableNodeReference : value(inr.value), unique(inr.unique) { } + __forceinline EvaluableNodeReference(bool value) + : value(value), unique(true) + { } + constexpr EvaluableNodeReference(double value) : value(value), unique(true) { } diff --git a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp index b3bb3c0a..6afdadf1 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp @@ -19,8 +19,6 @@ #include #include -//TODO 18652: evaluate InterpretNode_* for immediate returns - EvaluableNodeReference Interpreter::InterpretNode_ENT_REWRITE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -482,7 +480,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FILTER(EvaluableNode *en, } } else -#endif + #endif //need this in a block for multithreading above { PushNewConstructionContext(list, result_list, EvaluableNodeImmediateValueWithType(0.0), nullptr); @@ -816,8 +814,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_APPLY(EvaluableNode *en, b source->SetType(new_type, evaluableNodeManager); - //apply the new type, using whether or not it was a unique reference - EvaluableNodeReference result = InterpretNode(source); + //apply the new type, using whether or not it was a unique reference, + //passing through whether an immediate_result is desired + EvaluableNodeReference result = InterpretNode(source, immediate_result); return result; } @@ -1047,11 +1046,20 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_INDEX(EvaluableNo auto index = InterpretNodeForImmediateUse(ocn[1]); EvaluableNode **target = TraverseToDestinationFromTraversalPathList(&container.GetReference(), index, false); - EvaluableNodeType result = (target != nullptr ? ENT_TRUE : ENT_FALSE); + bool found = (target != nullptr); + + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(index); + evaluableNodeManager->FreeNodeTreeIfPossible(container); + return EvaluableNodeReference(found); + } - return evaluableNodeManager->ReuseOrAllocOneOfNodes(index, container, result); + return evaluableNodeManager->ReuseOrAllocOneOfNodes(index, container, found ? ENT_TRUE : ENT_FALSE); } +//TODO 18652: evaluate InterpretNode_* for immediate returns + EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_VALUE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); From 8607ea5234a34f52a834a5b0a5551917b0d9600a Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sat, 23 Dec 2023 12:43:23 -0500 Subject: [PATCH 20/55] 18652: More implementation --- .../InterpreterOpcodesTransformations.cpp | 37 +++++++++++-------- 1 file changed, 21 insertions(+), 16 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp index 6afdadf1..cd6b71d2 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp @@ -1058,8 +1058,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_INDEX(EvaluableNo return evaluableNodeManager->ReuseOrAllocOneOfNodes(index, container, found ? ENT_TRUE : ENT_FALSE); } -//TODO 18652: evaluate InterpretNode_* for immediate returns - EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_VALUE(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1068,45 +1066,45 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_VALUE(EvaluableNo return EvaluableNodeReference::Null(); //get assoc array to look up - auto collection = InterpretNodeForImmediateUse(ocn[0]); + auto container = InterpretNodeForImmediateUse(ocn[0]); - if(collection == nullptr) + if(container == nullptr) return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); - auto node_stack = CreateInterpreterNodeStackStateSaver(collection); + auto node_stack = CreateInterpreterNodeStackStateSaver(container); //get value to look up (will attempt to reuse this node below) auto value = InterpretNodeForImmediateUse(ocn[1]); - EvaluableNodeType result = ENT_FALSE; + bool found = false; //try to find value - if(collection->IsAssociativeArray()) + if(container->IsAssociativeArray()) { - for(auto &[_, cn] : collection->GetMappedChildNodesReference()) + for(auto &[_, cn] : container->GetMappedChildNodesReference()) { if(EvaluableNode::AreDeepEqual(cn, value)) { - result = ENT_TRUE; + found = true; break; } } } - else if(collection->IsOrderedArray()) + else if(container->IsOrderedArray()) { - for(auto &cn : collection->GetOrderedChildNodesReference()) + for(auto &cn : container->GetOrderedChildNodesReference()) { if(EvaluableNode::AreDeepEqual(cn, value)) { - result = ENT_TRUE; + found = true; break; } } } - else if(collection->GetType() == ENT_STRING && !EvaluableNode::IsEmptyNode(value)) + else if(container->GetType() == ENT_STRING && !EvaluableNode::IsEmptyNode(value)) { //compute regular expression - const std::string &s = collection->GetStringValue(); + const std::string &s = container->GetStringValue(); std::string value_as_str = EvaluableNode::ToStringPreservingOpcodeType(value); @@ -1122,10 +1120,17 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_VALUE(EvaluableNo } if(valid_rx && std::regex_match(s, rx)) - result = ENT_TRUE; + found = true; + } + + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(value); + evaluableNodeManager->FreeNodeTreeIfPossible(container); + return EvaluableNodeReference(found); } - return evaluableNodeManager->ReuseOrAllocOneOfNodes(value, collection, result); + return evaluableNodeManager->ReuseOrAllocOneOfNodes(value, container, found ? ENT_TRUE : ENT_FALSE); } EvaluableNodeReference Interpreter::InterpretNode_ENT_REMOVE(EvaluableNode *en, bool immediate_result) From 7595521d02c1e76db2ffa48e273dad6300f3e051 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sat, 23 Dec 2023 13:00:00 -0500 Subject: [PATCH 21/55] 18652: More implementation --- .../InterpreterOpcodesEntityControl.cpp | 20 ++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp index b7e35e5a..457e0260 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp @@ -19,8 +19,6 @@ #include #include -//TODO 18652: evaluate InterpretNode_* for immediate returns - EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_COMMENTS(EvaluableNode *en, bool immediate_result) { if(curEntity == nullptr) @@ -229,6 +227,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_RAND_SEED(Evalu if(entity == nullptr) return EvaluableNodeReference::Null(); + //TODO 18652: revisit this with new string ids std::string rand_state_string = entity->GetRandomState(); return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, rand_state_string), true); } @@ -289,7 +288,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_ROOT_PERMISSION if(entity == nullptr) return EvaluableNodeReference::Null(); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(asset_manager.DoesEntityHaveRootPermission(entity) ? ENT_TRUE : ENT_FALSE), true); + bool has_root = asset_manager.DoesEntityHaveRootPermission(entity); + if(immediate_result) + return EvaluableNodeReference(has_root); + + return EvaluableNodeReference(evaluableNodeManager->AllocNode(has_root ? ENT_TRUE : ENT_FALSE), true); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_ENTITY_ROOT_PERMISSION(EvaluableNode *en, bool immediate_result) @@ -544,6 +547,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DESTROY_ENTITIES(Evaluable delete source_entity; } + if(immediate_result) + return EvaluableNodeReference(all_destroys_successful); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_destroys_successful ? ENT_TRUE : ENT_FALSE), true); } @@ -641,7 +647,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LOAD_ENTITY_and_LOAD_PERSI destination_entity_parent->AddContainedEntityViaReference(loaded_entity, new_entity_id, writeListeners); if(destination_entity_parent == curEntity) + { + if(immediate_result) + return EvaluableNodeReference(new_entity_id); return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, new_entity_id), true); + } else //need to return an id path return EvaluableNodeReference(GetTraversalIDPathFromAToB(evaluableNodeManager, curEntity, loaded_entity), true); } @@ -698,6 +708,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_STORE(EvaluableNode *en, b evaluableNodeManager->FreeNodeTreeIfPossible(to_store); + if(immediate_result) + return EvaluableNodeReference(successful_save); return EvaluableNodeReference(evaluableNodeManager->AllocNode(successful_save ? ENT_TRUE : ENT_FALSE), true); } @@ -758,5 +770,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_STORE_ENTITY(EvaluableNode bool stored_successfully = asset_manager.StoreEntityToResourcePath(source_entity, resource_name, file_type, false, true, escape_filename, escape_contained_filenames, sort_keys); + if(immediate_result) + return EvaluableNodeReference(stored_successfully); return EvaluableNodeReference(evaluableNodeManager->AllocNode(stored_successfully ? ENT_TRUE : ENT_FALSE), true); } From 88e5623b0fe46c7415dffbf344fa936c5bf88ede Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sat, 23 Dec 2023 13:05:52 -0500 Subject: [PATCH 22/55] 18652: More implementation --- .../InterpreterOpcodesEntityAccess.cpp | 10 ++++-- src/Amalgam/out.txt | 36 ++++++++++--------- 2 files changed, 26 insertions(+), 20 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp index 56097c9d..51c1e497 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp @@ -22,8 +22,6 @@ #include #include -//TODO 18652: evaluate InterpretNode_* for immediate returns - EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_ENTITY(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -40,7 +38,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_ENTITY(EvaluableN EntityReadReference source_entity = TraverseToExistingEntityReferenceViaEvaluableNodeIDPath(curEntity, source_id_node); evaluableNodeManager->FreeNodeTreeIfPossible(source_id_node); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(source_entity != nullptr ? 1.0 : 0.0), true); + if(immediate_result) + return EvaluableNodeReference(source_entity != nullptr); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(source_entity != nullptr ? ENT_TRUE : ENT_FALSE), true); } EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINED_ENTITIES_and_COMPUTE_ON_CONTAINED_ENTITIES(EvaluableNode *en, bool immediate_result) @@ -212,6 +212,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_LABEL(EvaluableNo return EvaluableNodeReference::Null(); bool contains_label = target_entity->DoesLabelExist(label_sid); + if(immediate_result) + return EvaluableNodeReference(contains_label); return EvaluableNodeReference(evaluableNodeManager->AllocNode(contains_label ? ENT_TRUE : ENT_FALSE), true); } @@ -303,6 +305,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_TO_ENTITIES_and_DIR return EvaluableNodeReference::Null(); } + if(immediate_result) + return EvaluableNodeReference(all_assignments_successful); return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_assignments_successful ? ENT_TRUE : ENT_FALSE), true); } diff --git a/src/Amalgam/out.txt b/src/Amalgam/out.txt index d8e083f6..69b6f749 100644 --- a/src/Amalgam/out.txt +++ b/src/Amalgam/out.txt @@ -1236,7 +1236,7 @@ current_index: 2 8 ) accum_string "abcdef" - argv (list "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\src\\Amalgam\\./amlg_code/full_test.amlg") + argv (list "C:\\Users\\ChristopherHazard\\Desktop\\Howso_repos\\amalgam\\src\\Amalgam\\./amlg_code/full_test.amlg") bar (declare (assoc x 6) (+ x 2) @@ -1249,10 +1249,10 @@ current_index: 2 A (assoc B 2) B 2 ) - interpreter "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" + interpreter "C:\\Users\\ChristopherHazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" raaa 2 rwww 1 - start_time 1703262703.950872 + start_time 1703354714.826559 www 1 x 12 zz 10 @@ -1279,7 +1279,7 @@ current_index: 2 8 ) accum_string "abcdef" - argv (list "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\src\\Amalgam\\./amlg_code/full_test.amlg") + argv (list "C:\\Users\\ChristopherHazard\\Desktop\\Howso_repos\\amalgam\\src\\Amalgam\\./amlg_code/full_test.amlg") bar (declare (assoc x 6) (+ x 2) @@ -1292,10 +1292,10 @@ current_index: 2 A (assoc B 2) B 2 ) - interpreter "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" + interpreter "C:\\Users\\ChristopherHazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" raaa 2 rwww 1 - start_time 1703262703.950872 + start_time 1703354714.826559 www 1 x 12 zz 10 @@ -1321,7 +1321,7 @@ current_index: 2 8 ) accum_string "abcdef" - argv (list "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\src\\Amalgam\\./amlg_code/full_test.amlg") + argv (list "C:\\Users\\ChristopherHazard\\Desktop\\Howso_repos\\amalgam\\src\\Amalgam\\./amlg_code/full_test.amlg") bar (declare (assoc x 6) (+ x 2) @@ -1334,10 +1334,10 @@ current_index: 2 A (assoc B 2) B 2 ) - interpreter "C:\\Users\\Chris Hazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" + interpreter "C:\\Users\\ChristopherHazard\\Desktop\\Howso_repos\\amalgam\\x64\\MT_Release_EXE\\Amalgam.exe" raaa 2 rwww 1 - start_time 1703262703.950872 + start_time 1703354714.826559 www 1 x 12 zz 10 @@ -1605,7 +1605,7 @@ e: - .inf 25: (assoc a 1) -current date-time in epoch: 2023-12-22-11.31.44.3873840 +current date-time in epoch: 2023-12-23-13.05.14.9628270 2020-06-07 00:22:59 1391230800 1391230800 @@ -3431,7 +3431,7 @@ deep sets --set_entity_root_permission-- RootTest -1703262704.577977 +1703354715.822995 (true) RootTest @@ -3655,7 +3655,7 @@ hello ) ) ) - (set_entity_rand_seed new_entity "Ço¬‰OT40Ñ”-I´»ÿ") + (set_entity_rand_seed new_entity "ËrI˜¸\nL0Ñ”-I´»ÿ") (set_entity_rand_seed (first (create_entities @@ -3665,7 +3665,7 @@ hello ) ) ) - "'lòÝ>‡‰€\0«:¥Šÿ" + "Ç0¼”u?ýƒFVÁÃHÈW©ÿ" ) (set_entity_rand_seed (first @@ -3698,7 +3698,7 @@ hello ) ) ) - (set_entity_rand_seed new_entity "Ço¬‰OT40Ñ”-I´»ÿ") + (set_entity_rand_seed new_entity "ËrI˜¸\nL0Ñ”-I´»ÿ") (set_entity_rand_seed (first (create_entities @@ -3784,8 +3784,10 @@ store to .json normally (assoc c "c" d (null)) ) --contains_entity-- -1 -0 +(true) + +(false) + --contained_entities-- (list "Child1" @@ -4645,4 +4647,4 @@ Expecting 1000: 1000 concurrent entity writes successful: (true) --total execution time-- -1.1618399620056152 +2.398509979248047 From b3733ff123224f427a3f67e30a4652565d31ac8d Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sat, 23 Dec 2023 13:16:14 -0500 Subject: [PATCH 23/55] 18652: More implementation --- .../InterpreterOpcodesListManipulation.cpp | 25 +++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp index a7ecc75f..144b8c40 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp @@ -19,8 +19,6 @@ #include #include -//TODO 18652: evaluate InterpretNode_* for immediate returns - EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -85,6 +83,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en, b evaluableNodeManager->FreeNodeTreeIfPossible(list); + //TODO 18652: revisit this with new string ids return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, s.substr(0, utf8_char_length)), true); } @@ -101,6 +100,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en, b //return 1 if nonzero evaluableNodeManager->FreeNodeTreeIfPossible(list); + if(immediate_result) + return EvaluableNodeReference(1.0); return EvaluableNodeReference(evaluableNodeManager->AllocNode(1.0), true); } } @@ -214,6 +215,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAIL(EvaluableNode *en, bo //drop the number of characters before this length size_t utf8_start_offset = StringManipulation::GetNthUTF8CharacterOffset(s, num_chars_to_drop); + //TODO 18652: revisit this with new string ids EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(list, ENT_STRING); result->SetStringValue(s.substr(utf8_start_offset, s.size() - utf8_start_offset)); return result; @@ -226,6 +228,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAIL(EvaluableNode *en, bo if(value == 0.0) return list; + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(list); + return EvaluableNodeReference(value - 1.0); + } + //return (value - 1.0) if nonzero EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(list, ENT_NUMBER); result->SetNumberValue(value - 1.0); @@ -302,6 +310,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LAST(EvaluableNode *en, bo auto [utf8_char_start_offset, utf8_char_length] = StringManipulation::GetLastUTF8CharacterOffsetAndLength(s); + //TODO 18652: revisit this with new string ids EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(list, ENT_STRING); result->SetStringValue(s.substr(utf8_char_start_offset, utf8_char_length)); return result; @@ -314,6 +323,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LAST(EvaluableNode *en, bo if(value == 0.0) return list; + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(list); + return EvaluableNodeReference(1.0); + } + //return 1 if nonzero EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(list, ENT_NUMBER); result->SetNumberValue(1.0); @@ -430,6 +445,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUNC(EvaluableNode *en, b evaluableNodeManager->FreeNodeTreeIfPossible(list); + //TODO 18652: revisit this with new string ids return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, s.substr(0, utf8_end_offset)), true); } @@ -443,6 +459,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUNC(EvaluableNode *en, b //return (value - 1.0) if nonzero evaluableNodeManager->FreeNodeTreeIfPossible(list); + if(immediate_result) + return EvaluableNodeReference(value - 1.0); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value - 1.0), true); } } @@ -565,6 +584,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SIZE(EvaluableNode *en, bo evaluableNodeManager->FreeNodeTreeIfPossible(cur); } + if(immediate_result) + return EvaluableNodeReference(static_cast(size)); return EvaluableNodeReference(evaluableNodeManager->AllocNode(static_cast(size)), true); } From b0feaf2d2509ab350d6d7eba170a513edb11c6b4 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sat, 23 Dec 2023 13:33:34 -0500 Subject: [PATCH 24/55] 18652: More progress --- .../interpreter/InterpreterOpcodesLogic.cpp | 27 ++++++++++++++++--- .../interpreter/InterpreterOpcodesMath.cpp | 1 + 2 files changed, 25 insertions(+), 3 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp index d658992b..3b9c99c7 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp @@ -19,8 +19,6 @@ #include #include -//TODO 18652: evaluate InterpretNode_* for immediate returns - EvaluableNodeReference Interpreter::InterpretNode_ENT_AND(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -56,7 +54,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_AND(EvaluableNode *en, boo cur = InterpretNode(cn); if(!EvaluableNode::IsTrue(cur)) + { + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(cur); + return EvaluableNodeReference(false); + } + return evaluableNodeManager->ReuseOrAllocNode(cur, ENT_FALSE); + } } return cur; @@ -101,6 +107,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_OR(EvaluableNode *en, bool return cur; } + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(cur); + return EvaluableNodeReference(false); + } return evaluableNodeManager->ReuseOrAllocNode(cur, ENT_FALSE); } @@ -139,7 +150,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_XOR(EvaluableNode *en, boo } //if an odd number of true arguments, then return true - return EvaluableNodeReference(evaluableNodeManager->AllocNode((num_true % 2 == 1) ? ENT_TRUE : ENT_FALSE), true); + bool result = (num_true % 2 == 1); + + if(immediate_result) + return EvaluableNodeReference(result); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(result ? ENT_TRUE : ENT_FALSE), true); } EvaluableNodeReference Interpreter::InterpretNode_ENT_NOT(EvaluableNode *en, bool immediate_result) @@ -152,9 +167,15 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NOT(EvaluableNode *en, boo auto cur = InterpretNodeForImmediateUse(ocn[0]); bool is_true = EvaluableNode::IsTrue(cur); + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(cur); + return EvaluableNodeReference(is_true); + } return evaluableNodeManager->ReuseOrAllocNode(cur, is_true ? ENT_FALSE : ENT_TRUE); } +//TODO 18652: evaluate InterpretNode_* for immediate returns EvaluableNodeReference Interpreter::InterpretNode_ENT_EQUAL(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp index 793c124a..86209436 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp @@ -472,6 +472,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en, b if(num_params == 0) return EvaluableNodeReference::Null(); + //TODO 18652: revisit this regarding immeditaes EvaluableNodeReference retval; double number_value = 0.0; From 08ec410d43d54896658228a3abc9ae485c8cdb41 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sat, 23 Dec 2023 13:55:14 -0500 Subject: [PATCH 25/55] 18652: Fixes bug --- src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp index 3b9c99c7..bbb61525 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp @@ -170,7 +170,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NOT(EvaluableNode *en, boo if(immediate_result) { evaluableNodeManager->FreeNodeTreeIfPossible(cur); - return EvaluableNodeReference(is_true); + return EvaluableNodeReference(!is_true); } return evaluableNodeManager->ReuseOrAllocNode(cur, is_true ? ENT_FALSE : ENT_TRUE); } From bb27fdfa2bf8df7ebf03d1699f0009aa8b719509 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sat, 23 Dec 2023 22:18:45 -0500 Subject: [PATCH 26/55] 18652: Fixes bug with or opcode --- src/Amalgam/evaluablenode/EvaluableNode.h | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index 53d0dae6..204b5724 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1034,15 +1034,11 @@ class EvaluableNodeImmediateValueWithType __forceinline EvaluableNodeImmediateValueWithType(bool value) { + nodeType = ENIVT_NUMBER; if(value) - { - nodeType = ENIVT_NUMBER; nodeValue.number = 1.0; - } else - { - nodeType = ENIVT_NULL; - } + nodeValue.number = 0.0; } constexpr EvaluableNodeImmediateValueWithType(double number) @@ -1106,9 +1102,6 @@ class EvaluableNodeImmediateValueWithType bool GetValueAsBoolean() { - if(nodeType == ENIVT_NULL) - return false; - if(nodeType == ENIVT_NUMBER) { if(nodeValue.number == 0.0) @@ -1128,7 +1121,7 @@ class EvaluableNodeImmediateValueWithType if(nodeType == ENIVT_CODE) return EvaluableNode::IsTrue(nodeValue.code); - //nodeType is one of ENIVT_NOT_EXIST, ENIVT_NUMBER_INDIRECTION_INDEX + //nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX return false; } From 555757d43b22476eace4b9a6e99caceea76a8b54 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sat, 23 Dec 2023 22:51:07 -0500 Subject: [PATCH 27/55] 18652: More progress --- .../interpreter/InterpreterOpcodesBase.cpp | 28 ++++++++++--------- .../interpreter/InterpreterOpcodesMath.cpp | 1 - 2 files changed, 15 insertions(+), 14 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp index a828c33b..79f4ed1a 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp @@ -24,8 +24,6 @@ #include #include -//TODO 18652: evaluate InterpretNode_* for immediate returns - //Used only for deep debugging of entity memory and garbage collection std::string GetEntityMemorySizeDiagnostics(Entity *e) { @@ -286,6 +284,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_UNPARSE(EvaluableNode *en, auto tree = InterpretNodeForImmediateUse(ocn[0]); std::string s = Parser::Unparse(tree, evaluableNodeManager, pretty, true, deterministic_order); + //TODO 18652: revisit this with new string ids + EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(tree, ENT_STRING); result->SetStringValue(s); return result; @@ -300,12 +300,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_IF(EvaluableNode *en, bool for(size_t condition_num = 0; condition_num + 1 < num_cn; condition_num += 2) { if(InterpretNodeIntoBoolValue(ocn[condition_num])) - return InterpretNode(ocn[condition_num + 1]); + return InterpretNode(ocn[condition_num + 1], immediate_result); } //if made it here and one more condition, then it hit the last "else" branch, so exit evaluating to the else if(num_cn & 1) - return InterpretNode(ocn[num_cn - 1]); + return InterpretNode(ocn[num_cn - 1], immediate_result); //none were true return EvaluableNodeReference::Null(); @@ -328,11 +328,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SEQUENCE(EvaluableNode *en EvaluableNodeReference result = EvaluableNodeReference::Null(); for(auto &cn : en->GetOrderedChildNodes()) { - if(result != nullptr && result->GetType() == ENT_CONCLUDE) + if(!result.IsImmediateValue() && result != nullptr && result->GetType() == ENT_CONCLUDE) return RemoveConcludeFromConclusion(result, evaluableNodeManager); evaluableNodeManager->FreeNodeTreeIfPossible(result); - result = InterpretNode(cn); + result = InterpretNode(cn, immediate_result); } return result; } @@ -469,7 +469,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CALL(EvaluableNode *en, bo PushNewExecutionContext(new_context); //call the code - auto retval = InterpretNode(function); + auto retval = InterpretNode(function, immediate_result); //all finished with new context, but can't free it in case returning something PopExecutionContext(); @@ -608,9 +608,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_WHILE(EvaluableNode *en, b EvaluableNodeReference new_result; for(size_t i = 1; i < ocn_size; i++) { - new_result = InterpretNode(ocn[i]); + new_result = InterpretNode(ocn[i], immediate_result); - if(new_result != nullptr && new_result->GetType() == ENT_CONCLUDE) + if(!new_result.IsImmediateValue() && new_result != nullptr && new_result->GetType() == ENT_CONCLUDE) { //if previous result is unconsumed, free if possible previous_result = GetAndClearPreviousResultInConstructionStack(0); @@ -651,7 +651,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LET(EvaluableNode *en, boo EvaluableNodeReference result = EvaluableNodeReference::Null(); for(size_t i = 1; i < ocn.size(); i++) { - if(result != nullptr && result->GetType() == ENT_CONCLUDE) + if(!result.IsImmediateValue() && result != nullptr && result->GetType() == ENT_CONCLUDE) { PopExecutionContext(); return RemoveConcludeFromConclusion(result, evaluableNodeManager); @@ -659,7 +659,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LET(EvaluableNode *en, boo //free from previous iteration evaluableNodeManager->FreeNodeTreeIfPossible(result); - result = InterpretNode(ocn[i]); + result = InterpretNode(ocn[i], immediate_result); } //all finished with new context, but can't free it in case returning something @@ -744,11 +744,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DECLARE(EvaluableNode *en, //run code for(size_t i = 1; i < ocn.size(); i++) { - if(result != nullptr && result->GetType() == ENT_CONCLUDE) + if(!result.IsImmediateValue() && result != nullptr && result->GetType() == ENT_CONCLUDE) return RemoveConcludeFromConclusion(result, evaluableNodeManager); evaluableNodeManager->FreeNodeTreeIfPossible(result); - result = InterpretNode(ocn[i]); + result = InterpretNode(ocn[i], immediate_result); } return result; @@ -1218,6 +1218,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TARGET(EvaluableNode *en, return EvaluableNodeReference(constructionStackNodes->at(offset), false); } +//TODO 18652: evaluate InterpretNode_* for immediate returns + EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_INDEX(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp index 86209436..793c124a 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp @@ -472,7 +472,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en, b if(num_params == 0) return EvaluableNodeReference::Null(); - //TODO 18652: revisit this regarding immeditaes EvaluableNodeReference retval; double number_value = 0.0; From ef8d854ebcdd78c838f5b83ba38dfcce7ad13fea Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sun, 24 Dec 2023 17:36:11 -0500 Subject: [PATCH 28/55] 18652: Adds todo --- src/Amalgam/evaluablenode/EvaluableNode.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index 204b5724..d30a7b02 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1175,6 +1175,7 @@ class EvaluableNodeImmediateValueWithType return std::make_pair(false, ""); } + //TODO 18652: change the string ID methods to always create a reference and clean up as appropriate -- perhaps the string method always does a reference hand-off? StringInternPool::StringID GetValueAsStringIDIfExists() { if(nodeType == ENIVT_NUMBER) From 2413e7bd2b29df912bcda1840c55e68c5650bad6 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sun, 24 Dec 2023 17:55:31 -0500 Subject: [PATCH 29/55] 18652: More memory reuse --- .../interpreter/InterpreterOpcodesLogic.cpp | 60 ++++--------------- 1 file changed, 13 insertions(+), 47 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp index bbb61525..53594929 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp @@ -154,6 +154,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_XOR(EvaluableNode *en, boo if(immediate_result) return EvaluableNodeReference(result); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(result ? ENT_TRUE : ENT_FALSE), true); } @@ -206,9 +207,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EQUAL(EvaluableNode *en, b evaluableNodeManager->FreeNodeTreeIfPossible(cur); } - evaluableNodeManager->FreeNodeTreeIfPossible(to_match); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); + return evaluableNodeManager->ReuseOrAllocNode(to_match, ENT_TRUE); } #endif @@ -233,9 +232,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EQUAL(EvaluableNode *en, b evaluableNodeManager->FreeNodeTreeIfPossible(cur); } - evaluableNodeManager->FreeNodeTreeIfPossible(to_match); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); + return evaluableNodeManager->ReuseOrAllocNode(to_match, ENT_TRUE); } EvaluableNodeReference Interpreter::InterpretNode_ENT_NEQUAL(EvaluableNode *en, bool immediate_result) @@ -386,20 +383,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableN auto cur = InterpretNodeForImmediateUse(ocn[i]); if(EvaluableNode::IsEmptyNode(cur)) - { - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - evaluableNodeManager->FreeNodeTreeIfPossible(cur); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); - } + return evaluableNodeManager->ReuseOrAllocOneOfNodes(prev, cur, ENT_FALSE); if(!EvaluableNode::IsLessThan(prev, cur, en->GetType() == ENT_LEQUAL)) - { - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - evaluableNodeManager->FreeNodeTreeIfPossible(cur); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); - } + return evaluableNodeManager->ReuseOrAllocOneOfNodes(prev, cur, ENT_FALSE); evaluableNodeManager->FreeNodeTreeIfPossible(prev); prev = cur; @@ -408,10 +395,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableN node_stack.PushEvaluableNode(prev); } - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - //nothing is out of order - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); + return evaluableNodeManager->ReuseOrAllocNode(prev, ENT_TRUE); } EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(EvaluableNode *en, bool immediate_result) @@ -467,10 +452,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab auto prev = InterpretNodeForImmediateUse(ocn[0]); if(EvaluableNode::IsEmptyNode(prev)) - { - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); - } + return evaluableNodeManager->ReuseOrAllocNode(prev, ENT_FALSE); auto node_stack = CreateInterpreterNodeStackStateSaver(prev); @@ -480,20 +462,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab auto cur = InterpretNodeForImmediateUse(ocn[i]); if(EvaluableNode::IsEmptyNode(cur)) - { - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - evaluableNodeManager->FreeNodeTreeIfPossible(cur); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); - } - + return evaluableNodeManager->ReuseOrAllocOneOfNodes(prev, cur, ENT_FALSE); + if(!EvaluableNode::IsLessThan(cur, prev, en->GetType() == ENT_GEQUAL)) - { - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - evaluableNodeManager->FreeNodeTreeIfPossible(cur); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); - } + return evaluableNodeManager->ReuseOrAllocOneOfNodes(prev, cur, ENT_FALSE); evaluableNodeManager->FreeNodeTreeIfPossible(prev); prev = cur; @@ -502,10 +474,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab node_stack.PushEvaluableNode(prev); } - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - //nothing is out of order - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); + return evaluableNodeManager->ReuseOrAllocNode(prev, ENT_TRUE); } EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_EQUALS(EvaluableNode *en, bool immediate_result) @@ -551,9 +521,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_EQUALS(EvaluableNode evaluableNodeManager->FreeNodeTreeIfPossible(cur); } - evaluableNodeManager->FreeNodeTreeIfPossible(to_match); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); + return evaluableNodeManager->ReuseOrAllocNode(to_match, ENT_TRUE); } #endif @@ -591,9 +559,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_EQUALS(EvaluableNode evaluableNodeManager->FreeNodeTreeIfPossible(cur); } - evaluableNodeManager->FreeNodeTreeIfPossible(to_match); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); + return evaluableNodeManager->ReuseOrAllocNode(to_match, ENT_TRUE); } EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_NEQUALS(EvaluableNode *en, bool immediate_result) From f7e41072eb1e18d1c83d64a968b9c43f9a1fb7b3 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sun, 24 Dec 2023 19:32:22 -0500 Subject: [PATCH 30/55] 18652: More implementation progress --- .../interpreter/InterpreterOpcodesLogic.cpp | 96 +++++++++++++++---- 1 file changed, 76 insertions(+), 20 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp index 53594929..80898bb9 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp @@ -176,7 +176,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NOT(EvaluableNode *en, boo return evaluableNodeManager->ReuseOrAllocNode(cur, is_true ? ENT_FALSE : ENT_TRUE); } -//TODO 18652: evaluate InterpretNode_* for immediate returns EvaluableNodeReference Interpreter::InterpretNode_ENT_EQUAL(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -227,11 +226,25 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EQUAL(EvaluableNode *en, b } if(!EvaluableNode::AreDeepEqual(to_match, cur)) + { + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(to_match); + evaluableNodeManager->FreeNodeTreeIfPossible(cur); + return EvaluableNodeReference(false); + } + return evaluableNodeManager->ReuseOrAllocOneOfNodes(to_match, cur, ENT_FALSE); + } evaluableNodeManager->FreeNodeTreeIfPossible(cur); } + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(to_match); + return EvaluableNodeReference(true); + } return evaluableNodeManager->ReuseOrAllocNode(to_match, ENT_TRUE); } @@ -280,6 +293,13 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NEQUAL(EvaluableNode *en, EvaluableNodeReference b = InterpretNodeForImmediateUse(ocn[1]); bool a_b_not_equal = (!EvaluableNode::AreDeepEqual(a, b)); + + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(a); + evaluableNodeManager->FreeNodeTreeIfPossible(b); + return EvaluableNodeReference(a_b_not_equal); + } return evaluableNodeManager->ReuseOrAllocOneOfNodes(a, b, a_b_not_equal ? ENT_TRUE : ENT_FALSE); } @@ -315,6 +335,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NEQUAL(EvaluableNode *en, for(size_t i = 0; i < values.size(); i++) evaluableNodeManager->FreeNodeTreeIfPossible(values[i]); + if(immediate_result) + return EvaluableNodeReference(all_not_equal); return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_not_equal ? ENT_TRUE : ENT_FALSE), true); } @@ -371,10 +393,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableN auto prev = InterpretNodeForImmediateUse(ocn[0]); if(EvaluableNode::IsEmptyNode(prev)) - { - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); - } + return evaluableNodeManager->ReuseOrAllocNode(prev, ENT_FALSE); + auto node_stack = CreateInterpreterNodeStackStateSaver(prev); for(size_t i = 1; i < ocn.size(); i++) @@ -382,11 +402,17 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableN //if not in strict increasing order, return false auto cur = InterpretNodeForImmediateUse(ocn[i]); - if(EvaluableNode::IsEmptyNode(cur)) - return evaluableNodeManager->ReuseOrAllocOneOfNodes(prev, cur, ENT_FALSE); + if(EvaluableNode::IsEmptyNode(cur) + || !EvaluableNode::IsLessThan(prev, cur, en->GetType() == ENT_LEQUAL)) + { + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(prev); + return EvaluableNodeReference(false); + } - if(!EvaluableNode::IsLessThan(prev, cur, en->GetType() == ENT_LEQUAL)) return evaluableNodeManager->ReuseOrAllocOneOfNodes(prev, cur, ENT_FALSE); + } evaluableNodeManager->FreeNodeTreeIfPossible(prev); prev = cur; @@ -396,6 +422,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableN } //nothing is out of order + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(prev); + return EvaluableNodeReference(true); + } return evaluableNodeManager->ReuseOrAllocNode(prev, ENT_TRUE); } @@ -461,11 +492,17 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab //if not in strict increasing order, return false auto cur = InterpretNodeForImmediateUse(ocn[i]); - if(EvaluableNode::IsEmptyNode(cur)) - return evaluableNodeManager->ReuseOrAllocOneOfNodes(prev, cur, ENT_FALSE); - - if(!EvaluableNode::IsLessThan(cur, prev, en->GetType() == ENT_GEQUAL)) + if(EvaluableNode::IsEmptyNode(cur) + || !EvaluableNode::IsLessThan(cur, prev, en->GetType() == ENT_GEQUAL)) + { + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(prev); + return EvaluableNodeReference(false); + } + return evaluableNodeManager->ReuseOrAllocOneOfNodes(prev, cur, ENT_FALSE); + } evaluableNodeManager->FreeNodeTreeIfPossible(prev); prev = cur; @@ -475,6 +512,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab } //nothing is out of order + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(prev); + return EvaluableNodeReference(true); + } return evaluableNodeManager->ReuseOrAllocNode(prev, ENT_TRUE); } @@ -550,15 +592,24 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_EQUALS(EvaluableNode if(cur_type != to_match_type) { - evaluableNodeManager->FreeNodeTreeIfPossible(to_match); - evaluableNodeManager->FreeNodeTreeIfPossible(cur); + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(to_match); + evaluableNodeManager->FreeNodeTreeIfPossible(cur); + return EvaluableNodeReference(false); + } - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); + return evaluableNodeManager->ReuseOrAllocOneOfNodes(to_match, cur, ENT_FALSE); } evaluableNodeManager->FreeNodeTreeIfPossible(cur); } + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(to_match); + return EvaluableNodeReference(true); + } return evaluableNodeManager->ReuseOrAllocNode(to_match, ENT_TRUE); } @@ -569,9 +620,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_NEQUALS(EvaluableNode if(ocn.size() == 0) return EvaluableNodeReference::Null(); - EvaluableNodeType result_type = ENT_TRUE; - - std::vector values(ocn.size()); + std::vector values(ocn.size()); auto node_stack = CreateInterpreterNodeStackStateSaver(); @@ -582,6 +631,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_NEQUALS(EvaluableNode node_stack.PushEvaluableNode(values[i]); } + bool all_not_equal = true; for(size_t i = 0; i < ocn.size(); i++) { //start at next higher, because comparisons are symmetric and don't need to compare with self @@ -593,7 +643,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_NEQUALS(EvaluableNode //if they're equal, then it fails if((cur1 == nullptr && cur2 == nullptr) || (cur1 != nullptr && cur2 != nullptr && cur1->GetType() == cur2->GetType())) { - result_type = ENT_FALSE; + all_not_equal = false; //break out of loop i = ocn.size(); @@ -602,5 +652,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_NEQUALS(EvaluableNode } } - return EvaluableNodeReference(evaluableNodeManager->AllocNode(result_type), true); + for(size_t i = 0; i < values.size(); i++) + evaluableNodeManager->FreeNodeTreeIfPossible(values[i]); + + if(immediate_result) + return EvaluableNodeReference(all_not_equal); + + return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_not_equal ? ENT_TRUE : ENT_FALSE), true); } From 066f558c5f9846114670c139450bd52a397e64e3 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sun, 24 Dec 2023 19:40:31 -0500 Subject: [PATCH 31/55] 18652: More progress --- .../interpreter/InterpreterOpcodesBase.cpp | 12 ++++++++++-- .../interpreter/InterpreterOpcodesDataTypes.cpp | 17 +++++++++++++---- 2 files changed, 23 insertions(+), 6 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp index 79f4ed1a..455a7f18 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp @@ -1218,8 +1218,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TARGET(EvaluableNode *en, return EvaluableNodeReference(constructionStackNodes->at(offset), false); } -//TODO 18652: evaluate InterpretNode_* for immediate returns - EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_INDEX(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1245,9 +1243,17 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_INDEX(EvaluableNod EvaluableNode *index_node = nullptr; EvaluableNodeImmediateValueWithType enivwt = constructionStackIndicesAndUniqueness[offset].index; if(enivwt.nodeType == ENIVT_NUMBER) + { + if(immediate_result) + return EvaluableNodeReference(enivwt.nodeValue.number); index_node = evaluableNodeManager->AllocNode(enivwt.nodeValue.number); + } else if(enivwt.nodeType == ENIVT_STRING_ID) + { + if(immediate_result) + return EvaluableNodeReference(enivwt.nodeValue.stringID); index_node = evaluableNodeManager->AllocNode(ENT_STRING, enivwt.nodeValue.stringID); + } return EvaluableNodeReference(index_node, true); } @@ -1358,6 +1364,8 @@ EvaluableNodeReference GenerateRandomValueBasedOnRandParam(EvaluableNodeReferenc return EvaluableNodeReference::Null(); } +//TODO 18652: evaluate InterpretNode_* below for immediate returns + EvaluableNodeReference Interpreter::InterpretNode_ENT_RAND(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index cb74a26f..18b0ac0d 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -26,15 +26,17 @@ #include #include -//TODO 18652: evaluate InterpretNode_* for immediate returns - EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUE(EvaluableNode *en, bool immediate_result) { + if(immediate_result) + return EvaluableNodeReference(true); return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); } EvaluableNodeReference Interpreter::InterpretNode_ENT_FALSE(EvaluableNode *en, bool immediate_result) { + if(immediate_result) + return EvaluableNodeReference(false); return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); } @@ -182,12 +184,18 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSOC(EvaluableNode *en, b EvaluableNodeReference Interpreter::InterpretNode_ENT_NUMBER(EvaluableNode *en, bool immediate_result) { - return EvaluableNodeReference(evaluableNodeManager->AllocNode(en->GetNumberValueReference()), true); + double value = en->GetNumberValueReference(); + if(immediate_result) + return EvaluableNodeReference(value); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } EvaluableNodeReference Interpreter::InterpretNode_ENT_STRING(EvaluableNode *en, bool immediate_result) { - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, en->GetStringIDReference()), true); + StringInternPool::StringID value = en->GetStringIDReference(); + if(immediate_result) + return EvaluableNodeReference(value); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, value), true); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SYMBOL(EvaluableNode *en, bool immediate_result) @@ -224,6 +232,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE(EvaluableNode *en return EvaluableNodeReference(evaluableNodeManager->AllocNode(type), true); } +//TODO 18652: evaluate InterpretNode_* below for immediate returns EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE_STRING(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); From 98a8e6b8d787e3ce144e99a40fce6cb816d97cd5 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sun, 24 Dec 2023 20:05:02 -0500 Subject: [PATCH 32/55] 18652: More progress --- src/Amalgam/evaluablenode/EvaluableNode.h | 23 +---------------------- src/Amalgam/interpreter/Interpreter.cpp | 2 +- 2 files changed, 2 insertions(+), 23 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index d30a7b02..9e854d7f 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1176,7 +1176,7 @@ class EvaluableNodeImmediateValueWithType } //TODO 18652: change the string ID methods to always create a reference and clean up as appropriate -- perhaps the string method always does a reference hand-off? - StringInternPool::StringID GetValueAsStringIDIfExists() + StringInternPool::StringID GetValueAsStringID() { if(nodeType == ENIVT_NUMBER) { @@ -1198,27 +1198,6 @@ class EvaluableNodeImmediateValueWithType return string_intern_pool.NOT_A_STRING_ID; } - StringInternPool::StringID GetValueAsStringIDWithReference() - { - if(nodeType == ENIVT_NUMBER) - { - if(FastIsNaN(nodeValue.number)) - return StringInternPool::NOT_A_STRING_ID; - - const std::string str_value = EvaluableNode::NumberToString(nodeValue.number); - return string_intern_pool.CreateStringReference(str_value); - } - - if(nodeType == ENIVT_STRING_ID) - return string_intern_pool.CreateStringReference(nodeValue.stringID); - - if(nodeType == ENIVT_CODE) - return EvaluableNode::ToStringIDWithReference(nodeValue.code); - - //nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX - return string_intern_pool.NOT_A_STRING_ID; - } - static inline bool AreEqual(EvaluableNodeImmediateValueWithType &a, EvaluableNodeImmediateValueWithType &b) { return EvaluableNodeImmediateValue::AreEqual(a.nodeType, a.nodeValue, b.nodeType, b.nodeValue); diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index 8589d028..4b90430e 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -560,7 +560,7 @@ StringInternPool::StringID Interpreter::InterpretNodeIntoStringIDValueIfExists(E auto result = InterpretNodeForImmediateUse(n, true); auto &result_value = result.GetValue(); - auto sid = result_value.GetValueAsStringIDIfExists(); + auto sid = result_value.GetValueAsStringID(); evaluableNodeManager->FreeNodeTreeIfPossible(result); return sid; From b05feaee252daeba1321b17fd434532fbf272165 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Sun, 24 Dec 2023 20:10:50 -0500 Subject: [PATCH 33/55] 18652: Updates todos --- src/Amalgam/evaluablenode/EvaluableNode.h | 1 - src/Amalgam/evaluablenode/EvaluableNodeManagement.h | 3 +++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index 9e854d7f..d3844492 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1175,7 +1175,6 @@ class EvaluableNodeImmediateValueWithType return std::make_pair(false, ""); } - //TODO 18652: change the string ID methods to always create a reference and clean up as appropriate -- perhaps the string method always does a reference hand-off? StringInternPool::StringID GetValueAsStringID() { if(nodeType == ENIVT_NUMBER) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index f81de19c..79b63dd9 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -33,6 +33,9 @@ class EvaluableNodeReference : value(value), unique(true) { } + + //TODO 18652: change the string ID methods to always create a reference and clean up as appropriate -- perhaps the string method always does a reference hand-off? + //TODO 18652: add constructor that uses std::string and creates the reference constexpr EvaluableNodeReference(StringInternPool::StringID string_id) : value(string_id), unique(true) { } From 1d7dfaeb0035525459272a19f4a44cb6a84f7b4e Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Mon, 25 Dec 2023 11:29:09 -0500 Subject: [PATCH 34/55] 18652: Adds string id references to immediates --- .../evaluablenode/EvaluableNodeManagement.h | 17 ++++++++++++----- src/Amalgam/interpreter/Interpreter.cpp | 4 ++++ 2 files changed, 16 insertions(+), 5 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index 79b63dd9..19323e40 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -33,13 +33,20 @@ class EvaluableNodeReference : value(value), unique(true) { } - - //TODO 18652: change the string ID methods to always create a reference and clean up as appropriate -- perhaps the string method always does a reference hand-off? - //TODO 18652: add constructor that uses std::string and creates the reference - constexpr EvaluableNodeReference(StringInternPool::StringID string_id) - : value(string_id), unique(true) + __forceinline EvaluableNodeReference(StringInternPool::StringID string_id) + : value(string_intern_pool.CreateStringReference(string_id)), unique(true) { } + //frees resources associated with immediate values + //note that this could be placed in a destructor, but this is such a rare use, + //i.e., only when an immediate value is requested, and the references are usually handled specially, + //that it's just as complex to put it in the destructor but will incur more overhead + __forceinline void FreeImmediateResources() + { + if(IsImmediateValue() && value.nodeType == ENIVT_STRING_ID) + string_intern_pool.DestroyStringReference(value.nodeValue.stringID); + } + //when attached a child node, make sure that this node reflects the same properties void UpdatePropertiesBasedOnAttachedNode(EvaluableNodeReference &attached) { diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index 4b90430e..668ae03f 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -547,6 +547,7 @@ std::pair Interpreter::InterpretNodeIntoStringValue(Evaluable auto [valid, str] = result_value.GetValueAsString(); evaluableNodeManager->FreeNodeTreeIfPossible(result); + result.FreeImmediateResources(); return std::make_pair(valid, str); } @@ -562,6 +563,8 @@ StringInternPool::StringID Interpreter::InterpretNodeIntoStringIDValueIfExists(E auto sid = result_value.GetValueAsStringID(); evaluableNodeManager->FreeNodeTreeIfPossible(result); + //ID already exists outside of this, so not expecting to keep this reference + result.FreeImmediateResources(); return sid; } @@ -633,6 +636,7 @@ double Interpreter::InterpretNodeIntoNumberValue(EvaluableNode *n) double value = result_value.GetValueAsNumber(); evaluableNodeManager->FreeNodeTreeIfPossible(result); + result.FreeImmediateResources(); return value; } From 613e7c3fe83d88c06f007ed1c71744621f2c0ef6 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Mon, 25 Dec 2023 11:46:53 -0500 Subject: [PATCH 35/55] 18652: More implementation progress --- src/Amalgam/evaluablenode/EvaluableNode.h | 24 ++++++++++- .../evaluablenode/EvaluableNodeManagement.h | 4 ++ src/Amalgam/interpreter/Interpreter.cpp | 43 ++++++++++++------- .../InterpreterOpcodesEntityControl.cpp | 2 +- 4 files changed, 55 insertions(+), 18 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNode.h b/src/Amalgam/evaluablenode/EvaluableNode.h index d3844492..c4567cfd 100644 --- a/src/Amalgam/evaluablenode/EvaluableNode.h +++ b/src/Amalgam/evaluablenode/EvaluableNode.h @@ -1175,7 +1175,7 @@ class EvaluableNodeImmediateValueWithType return std::make_pair(false, ""); } - StringInternPool::StringID GetValueAsStringID() + StringInternPool::StringID GetValueAsStringIDIfExists() { if(nodeType == ENIVT_NUMBER) { @@ -1197,6 +1197,28 @@ class EvaluableNodeImmediateValueWithType return string_intern_pool.NOT_A_STRING_ID; } + StringInternPool::StringID GetValueAsStringIDWithReference() + { + if(nodeType == ENIVT_NUMBER) + { + if(FastIsNaN(nodeValue.number)) + return StringInternPool::NOT_A_STRING_ID; + + const std::string str_value = EvaluableNode::NumberToString(nodeValue.number); + //will return empty string if not found + return string_intern_pool.CreateStringReference(str_value); + } + + if(nodeType == ENIVT_STRING_ID) + return string_intern_pool.CreateStringReference(nodeValue.stringID); + + if(nodeType == ENIVT_CODE) + return EvaluableNode::ToStringIDWithReference(nodeValue.code); + + //nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX + return string_intern_pool.NOT_A_STRING_ID; + } + static inline bool AreEqual(EvaluableNodeImmediateValueWithType &a, EvaluableNodeImmediateValueWithType &b) { return EvaluableNodeImmediateValue::AreEqual(a.nodeType, a.nodeValue, b.nodeType, b.nodeValue); diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index 19323e40..d782cad3 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -37,6 +37,10 @@ class EvaluableNodeReference : value(string_intern_pool.CreateStringReference(string_id)), unique(true) { } + __forceinline EvaluableNodeReference(const std::string &str) + : value(string_intern_pool.CreateStringReference(str)), unique(true) + { } + //frees resources associated with immediate values //note that this could be placed in a destructor, but this is such a rare use, //i.e., only when an immediate value is requested, and the references are usually handled specially, diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index 668ae03f..53fe0ca6 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -561,7 +561,7 @@ StringInternPool::StringID Interpreter::InterpretNodeIntoStringIDValueIfExists(E auto result = InterpretNodeForImmediateUse(n, true); auto &result_value = result.GetValue(); - auto sid = result_value.GetValueAsStringID(); + auto sid = result_value.GetValueAsStringIDIfExists(); evaluableNodeManager->FreeNodeTreeIfPossible(result); //ID already exists outside of this, so not expecting to keep this reference result.FreeImmediateResources(); @@ -575,27 +575,38 @@ StringInternPool::StringID Interpreter::InterpretNodeIntoStringIDValueWithRefere if(n != nullptr && n->GetType() == ENT_STRING) return string_intern_pool.CreateStringReference(n->GetStringID()); - //TODO 18652: implement special paths for this -- need to balance extra overhead for methods that don't return immediates - - auto result = InterpretNodeForImmediateUse(n); + auto result = InterpretNodeForImmediateUse(n, true); - StringInternPool::StringID result_sid = string_intern_pool.NOT_A_STRING_ID; - //if have a unique string, then just grab the string's reference instead of creating a new one - if(result.unique) + if(result.IsImmediateValue()) { - if(result != nullptr && result->IsStringValue()) - result_sid = result->GetAndClearStringIDWithReference(); - else - result_sid = EvaluableNode::ToStringIDWithReference(result); + auto &result_value = result.GetValue(); - evaluableNodeManager->FreeNodeTree(result); + //reuse the reference if it has one + if(result_value.nodeType == ENIVT_STRING_ID) + return result_value.nodeValue.stringID; + + //create new reference + return result_value.GetValueAsStringIDWithReference(); } - else //not unique, so can't free + else //not immediate { - result_sid = EvaluableNode::ToStringIDWithReference(result); + //if have a unique string, then just grab the string's reference instead of creating a new one + if(result.unique) + { + StringInternPool::StringID result_sid = string_intern_pool.NOT_A_STRING_ID; + if(result != nullptr && result->IsStringValue()) + result_sid = result->GetAndClearStringIDWithReference(); + else + result_sid = EvaluableNode::ToStringIDWithReference(result); + + evaluableNodeManager->FreeNodeTree(result); + return result_sid; + } + else //not unique, so can't free + { + return EvaluableNode::ToStringIDWithReference(result); + } } - - return result_sid; } EvaluableNode *Interpreter::InterpretNodeIntoUniqueStringIDValueEvaluableNode(EvaluableNode *n) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp index 457e0260..8336eaae 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp @@ -649,7 +649,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LOAD_ENTITY_and_LOAD_PERSI if(destination_entity_parent == curEntity) { if(immediate_result) - return EvaluableNodeReference(new_entity_id); + return EvaluableNodeReference(static_cast(new_entity_id)); return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, new_entity_id), true); } else //need to return an id path From b771e626f9908aa9c608b1afb861a1d191496f4c Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Mon, 25 Dec 2023 11:59:36 -0500 Subject: [PATCH 36/55] 18652: More implementation --- src/Amalgam/interpreter/InterpreterOpcodesBase.cpp | 7 +++++-- src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp | 5 ++++- .../interpreter/InterpreterOpcodesEntityControl.cpp | 4 +++- 3 files changed, 12 insertions(+), 4 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp index 455a7f18..dabfac1a 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp @@ -284,8 +284,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_UNPARSE(EvaluableNode *en, auto tree = InterpretNodeForImmediateUse(ocn[0]); std::string s = Parser::Unparse(tree, evaluableNodeManager, pretty, true, deterministic_order); - //TODO 18652: revisit this with new string ids - + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(tree); + return EvaluableNodeReference(s); + } EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(tree, ENT_STRING); result->SetStringValue(s); return result; diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index 18b0ac0d..83aba3ea 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -232,7 +232,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE(EvaluableNode *en return EvaluableNodeReference(evaluableNodeManager->AllocNode(type), true); } -//TODO 18652: evaluate InterpretNode_* below for immediate returns EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE_STRING(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -247,6 +246,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE_STRING(EvaluableN evaluableNodeManager->FreeNodeTreeIfPossible(cur); std::string type_string = GetStringFromEvaluableNodeType(type, true); + if(immediate_result) + return EvaluableNodeReference(type_string); return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, type_string), true); } @@ -296,6 +297,8 @@ constexpr DestinationType ExpandCharStorage(char &value) return static_cast(reinterpret_cast(value)); } +//TODO 18652: evaluate InterpretNode_* below for immediate returns + EvaluableNodeReference Interpreter::InterpretNode_ENT_FORMAT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp index 8336eaae..613bfbbc 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp @@ -227,8 +227,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_RAND_SEED(Evalu if(entity == nullptr) return EvaluableNodeReference::Null(); - //TODO 18652: revisit this with new string ids std::string rand_state_string = entity->GetRandomState(); + + if(immediate_result) + return EvaluableNodeReference(rand_state_string); return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, rand_state_string), true); } From 7d9ea2e43e4a2a2148204862fbfea264e830a1e0 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Mon, 25 Dec 2023 12:18:17 -0500 Subject: [PATCH 37/55] 18652: Fixes resource leak --- src/Amalgam/interpreter/Interpreter.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index 53fe0ca6..27ea16cf 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -681,6 +681,7 @@ bool Interpreter::InterpretNodeIntoBoolValue(EvaluableNode *n, bool value_if_nul bool value = result_value.GetValueAsBoolean(); evaluableNodeManager->FreeNodeTreeIfPossible(result); + result.FreeImmediateResources(); return value; } From a35ced5adc32a317db9541fd226e99fdb36c8658 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Mon, 25 Dec 2023 19:42:02 -0500 Subject: [PATCH 38/55] 18652: More implementation --- .../InterpreterOpcodesListManipulation.cpp | 30 ++++++++++++++----- 1 file changed, 22 insertions(+), 8 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp index 144b8c40..5babfacc 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp @@ -83,8 +83,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en, b evaluableNodeManager->FreeNodeTreeIfPossible(list); - //TODO 18652: revisit this with new string ids - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, s.substr(0, utf8_char_length)), true); + std::string substring = s.substr(0, utf8_char_length); + if(immediate_result) + return EvaluableNodeReference(substring); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, substring), true); } if(DoesEvaluableNodeTypeUseNumberData(list->GetType())) @@ -215,9 +217,14 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAIL(EvaluableNode *en, bo //drop the number of characters before this length size_t utf8_start_offset = StringManipulation::GetNthUTF8CharacterOffset(s, num_chars_to_drop); - //TODO 18652: revisit this with new string ids + std::string substring = s.substr(utf8_start_offset, s.size() - utf8_start_offset); + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(list); + return EvaluableNodeReference(substring); + } EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(list, ENT_STRING); - result->SetStringValue(s.substr(utf8_start_offset, s.size() - utf8_start_offset)); + result->SetStringValue(substring); return result; } @@ -310,9 +317,14 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LAST(EvaluableNode *en, bo auto [utf8_char_start_offset, utf8_char_length] = StringManipulation::GetLastUTF8CharacterOffsetAndLength(s); - //TODO 18652: revisit this with new string ids + std::string substring = s.substr(utf8_char_start_offset, utf8_char_length); + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(list); + return EvaluableNodeReference(substring); + } EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(list, ENT_STRING); - result->SetStringValue(s.substr(utf8_char_start_offset, utf8_char_length)); + result->SetStringValue(substring); return result; } @@ -445,8 +457,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUNC(EvaluableNode *en, b evaluableNodeManager->FreeNodeTreeIfPossible(list); - //TODO 18652: revisit this with new string ids - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, s.substr(0, utf8_end_offset)), true); + std::string substring = s.substr(0, utf8_end_offset); + if(immediate_result) + return EvaluableNodeReference(substring); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, substring), true); } if(DoesEvaluableNodeTypeUseNumberData(list->GetType())) From 30bf2da75ca3aed1a4d2ba05dc9c43bf38cc3662 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Mon, 25 Dec 2023 19:49:27 -0500 Subject: [PATCH 39/55] 18652: More progress --- .../interpreter/InterpreterOpcodesBase.cpp | 25 ++++++++++++++----- 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp index dabfac1a..2d5ee415 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp @@ -1345,7 +1345,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ARGS(EvaluableNode *en, bo //Generates an EvaluableNode containing a random value based on the random parameter param, using enm and random_stream // if any part of param is preserved in the return value, then can_free_param will be set to false, otherwise it will be left alone -EvaluableNodeReference GenerateRandomValueBasedOnRandParam(EvaluableNodeReference param, EvaluableNodeManager *enm, RandomStream &random_stream, bool &can_free_param) +EvaluableNodeReference GenerateRandomValueBasedOnRandParam(EvaluableNodeReference param, EvaluableNodeManager *enm, + RandomStream &random_stream, bool &can_free_param, bool immediate_result) { if(param == nullptr) return EvaluableNodeReference(enm->AllocNode(random_stream.RandFull()), true); @@ -1361,20 +1362,26 @@ EvaluableNodeReference GenerateRandomValueBasedOnRandParam(EvaluableNodeReferenc if(DoesEvaluableNodeTypeUseNumberData(param->GetType())) { double value = random_stream.RandFull() * param->GetNumberValueReference(); + + if(immediate_result) + return EvaluableNodeReference(value); return EvaluableNodeReference(enm->AllocNode(value), true); } return EvaluableNodeReference::Null(); } -//TODO 18652: evaluate InterpretNode_* below for immediate returns - EvaluableNodeReference Interpreter::InterpretNode_ENT_RAND(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() == 0) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(randomStream.RandFull()), true); + { + double r = randomStream.RandFull(); + if(immediate_result) + return EvaluableNodeReference(r); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(r), true); + } //get number to generate bool generate_list = false; @@ -1402,7 +1409,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RAND(EvaluableNode *en, bo if(!generate_list) { bool can_free_param = true; - EvaluableNodeReference rand_value = GenerateRandomValueBasedOnRandParam(param, evaluableNodeManager, randomStream, can_free_param); + EvaluableNodeReference rand_value = GenerateRandomValueBasedOnRandParam(param, + evaluableNodeManager, randomStream, can_free_param, immediate_result); if(can_free_param) evaluableNodeManager->FreeNodeTreeIfPossible(param); @@ -1464,7 +1472,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RAND(EvaluableNode *en, bo bool can_free_param = true; for(size_t i = 0; i < number_to_generate; i++) { - EvaluableNodeReference rand_value = GenerateRandomValueBasedOnRandParam(param, evaluableNodeManager, randomStream, can_free_param); + EvaluableNodeReference rand_value = GenerateRandomValueBasedOnRandParam(param, + evaluableNodeManager, randomStream, can_free_param, immediate_result); retval->AppendOrderedChildNode(rand_value); retval.UpdatePropertiesBasedOnAttachedNode(rand_value); } @@ -1848,6 +1857,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_WEIGHTED_RAND(EvaluableNod EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_RAND_SEED(EvaluableNode *en, bool immediate_result) { std::string rand_state_string = randomStream.GetState(); + if(immediate_result) + return EvaluableNodeReference(rand_state_string); return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, rand_state_string), true); } @@ -1880,6 +1891,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM_TIME(EvaluableNode std::chrono::duration> double_duration_us = duration_us; double sec = double_duration_us.count(); + if(immediate_result) + return EvaluableNodeReference(sec); return EvaluableNodeReference(evaluableNodeManager->AllocNode(sec), true); } From b0f6362941e8bdc2aca7f032d39feec9d773850e Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 09:18:19 -0500 Subject: [PATCH 40/55] 18652: Implements immediate handling for format opcode --- .../InterpreterOpcodesDataTypes.cpp | 29 ++++++++++++------- 1 file changed, 19 insertions(+), 10 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index 83aba3ea..b6bf9440 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -297,8 +297,6 @@ constexpr DestinationType ExpandCharStorage(char &value) return static_cast(reinterpret_cast(value)); } -//TODO 18652: evaluate InterpretNode_* below for immediate returns - EvaluableNodeReference Interpreter::InterpretNode_ENT_FORMAT(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -587,12 +585,17 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FORMAT(EvaluableNode *en, number_value = EvaluableNode::ToNumber(code_value); string_intern_pool.DestroyStringReference(to_type); - evaluableNodeManager->FreeNodeTreeIfPossible(to_params); - //didn't return code_value, so can free it - evaluableNodeManager->FreeNodeTreeIfPossible(code_value); + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(to_params); + evaluableNodeManager->FreeNodeTreeIfPossible(code_value); + return EvaluableNodeReference(number_value); + } - return EvaluableNodeReference(evaluableNodeManager->AllocNode(number_value), true); + auto result = evaluableNodeManager->ReuseOrAllocOneOfNodes(to_params, code_value, ENT_NUMBER); + result->SetNumberValue(number_value); + return result; } else if(to_type == ENBISI_code) { @@ -891,12 +894,17 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FORMAT(EvaluableNode *en, } string_intern_pool.DestroyStringReference(to_type); - evaluableNodeManager->FreeNodeTreeIfPossible(to_params); - //didn't return code_value, so can free it - evaluableNodeManager->FreeNodeTreeIfPossible(code_value); + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(to_params); + evaluableNodeManager->FreeNodeTreeIfPossible(code_value); + return EvaluableNodeReference(string_value); + } - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, string_value), true); + auto result = evaluableNodeManager->ReuseOrAllocOneOfNodes(to_params, code_value, ENT_STRING); + result->SetStringValue(string_value); + return result; } EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_LABELS(EvaluableNode *en, bool immediate_result) @@ -1068,6 +1076,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ZIP_LABELS(EvaluableNode * return retval; } +//TODO 18652: evaluate InterpretNode_* below for immediate returns EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_COMMENTS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); From 2b93a65790451a460b76bd29d86e1fce8c0b5aac Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 09:27:28 -0500 Subject: [PATCH 41/55] 18652: More progress --- .../interpreter/InterpreterOpcodesDataTypes.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index b6bf9440..b30b274f 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -1076,7 +1076,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ZIP_LABELS(EvaluableNode * return retval; } -//TODO 18652: evaluate InterpretNode_* below for immediate returns EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_COMMENTS(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1094,6 +1093,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_COMMENTS(EvaluableNode if(comments_sid == StringInternPool::NOT_A_STRING_ID) return EvaluableNodeReference::Null(); + if(immediate_result) + return EvaluableNodeReference(comments_sid); return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, comments_sid), true); } @@ -1128,7 +1129,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_CONCURRENCY(EvaluableN auto n = InterpretNodeForImmediateUse(ocn[0]); if(n == nullptr) return EvaluableNodeReference::Null(); - + + if(immediate_result) + return EvaluableNodeReference(n->GetConcurrency()); return EvaluableNodeReference(evaluableNodeManager->AllocNode(n->GetConcurrency() ? ENT_TRUE : ENT_FALSE), true); } @@ -1165,13 +1168,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_VALUE(EvaluableNode *e return EvaluableNodeReference::Null(); if(n.unique) - { n->ClearMetadata(); - } else - { evaluableNodeManager->EnsureNodeIsModifiable(n, EvaluableNodeManager::ENMM_REMOVE_ALL); - } return n; } @@ -1399,6 +1398,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SPLIT(EvaluableNode *en, b return retval; } +//TODO 18652: evaluate InterpretNode_* below for immediate returns EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); From 67476d89c4451b5e98ac3bb4a53a241c9227f4f6 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 10:17:02 -0500 Subject: [PATCH 42/55] 18652: Code cleanup --- .../evaluablenode/EvaluableNodeManagement.h | 7 +++++ src/Amalgam/interpreter/Interpreter.h | 3 +- .../interpreter/InterpreterOpcodesBase.cpp | 17 ++++------- .../InterpreterOpcodesDataTypes.cpp | 20 +++++-------- .../InterpreterOpcodesEntityAccess.cpp | 13 ++------- .../InterpreterOpcodesEntityControl.cpp | 19 ++----------- .../interpreter/InterpreterOpcodesLogic.cpp | 15 ++-------- .../interpreter/InterpreterOpcodesMath.cpp | 28 +++++++++---------- 8 files changed, 44 insertions(+), 78 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index d782cad3..e62221c1 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -241,6 +241,13 @@ class EvaluableNodeManager return n; } + inline EvaluableNode *AllocNode(bool bool_value) + { + EvaluableNode *n = AllocUninitializedNode(); + n->InitializeType(bool_value ? ENT_TRUE : ENT_FALSE); + return n; + } + inline EvaluableNode *AllocNode(EvaluableNodeType type) { EvaluableNode *n = AllocUninitializedNode(); diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index bd2819d2..075f6d6c 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -296,7 +296,8 @@ class Interpreter EvaluableNode *GetCurrentExecutionContext(); //returns an EvaluableNodeReference for value, allocating if necessary based on if immediate result is needed - inline EvaluableNodeReference AllocNumberReturn(double value, bool immediate_result) + template + inline EvaluableNodeReference AllocReturn(T value, bool immediate_result) { if(immediate_result) return EvaluableNodeReference(value); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp index 2d5ee415..c828e9fd 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp @@ -1243,22 +1243,19 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_INDEX(EvaluableNod size_t offset = constructionStackIndicesAndUniqueness.size() - depth - 1; //build the index node to return - EvaluableNode *index_node = nullptr; EvaluableNodeImmediateValueWithType enivwt = constructionStackIndicesAndUniqueness[offset].index; if(enivwt.nodeType == ENIVT_NUMBER) { - if(immediate_result) - return EvaluableNodeReference(enivwt.nodeValue.number); - index_node = evaluableNodeManager->AllocNode(enivwt.nodeValue.number); + return AllocReturn(enivwt.nodeValue.number, immediate_result); } else if(enivwt.nodeType == ENIVT_STRING_ID) { if(immediate_result) return EvaluableNodeReference(enivwt.nodeValue.stringID); - index_node = evaluableNodeManager->AllocNode(ENT_STRING, enivwt.nodeValue.stringID); + return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, enivwt.nodeValue.stringID), true); } - return EvaluableNodeReference(index_node, true); + return EvaluableNodeReference::Null(); } EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_VALUE(EvaluableNode *en, bool immediate_result) @@ -1378,9 +1375,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RAND(EvaluableNode *en, bo if(ocn.size() == 0) { double r = randomStream.RandFull(); - if(immediate_result) - return EvaluableNodeReference(r); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(r), true); + return AllocReturn(r, immediate_result); } //get number to generate @@ -1891,9 +1886,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM_TIME(EvaluableNode std::chrono::duration> double_duration_us = duration_us; double sec = double_duration_us.count(); - if(immediate_result) - return EvaluableNodeReference(sec); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(sec), true); + return AllocReturn(sec, immediate_result); } //error handling diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index b30b274f..f75b3797 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -28,16 +28,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUE(EvaluableNode *en, bool immediate_result) { - if(immediate_result) - return EvaluableNodeReference(true); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); + return AllocReturn(true, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_FALSE(EvaluableNode *en, bool immediate_result) { - if(immediate_result) - return EvaluableNodeReference(false); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); + return AllocReturn(false, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_NULL(EvaluableNode *en, bool immediate_result) @@ -185,9 +181,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSOC(EvaluableNode *en, b EvaluableNodeReference Interpreter::InterpretNode_ENT_NUMBER(EvaluableNode *en, bool immediate_result) { double value = en->GetNumberValueReference(); - if(immediate_result) - return EvaluableNodeReference(value); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocReturn(value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_STRING(EvaluableNode *en, bool immediate_result) @@ -1129,10 +1123,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_CONCURRENCY(EvaluableN auto n = InterpretNodeForImmediateUse(ocn[0]); if(n == nullptr) return EvaluableNodeReference::Null(); - - if(immediate_result) - return EvaluableNodeReference(n->GetConcurrency()); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(n->GetConcurrency() ? ENT_TRUE : ENT_FALSE), true); + + return AllocReturn(n->GetConcurrency(), immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_CONCURRENCY(EvaluableNode *en, bool immediate_result) @@ -1399,6 +1391,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SPLIT(EvaluableNode *en, b } //TODO 18652: evaluate InterpretNode_* below for immediate returns +//TODO 18652: expand AllocReturn to include reusing 1 or 2 nodes, as well as handling string types (may need to remove the int/size variant of AllocNode) +//TODO 18652: consider lambda function to make single value mathematical opcodes more compact EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp index 51c1e497..1a4f9d9d 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityAccess.cpp @@ -38,9 +38,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_ENTITY(EvaluableN EntityReadReference source_entity = TraverseToExistingEntityReferenceViaEvaluableNodeIDPath(curEntity, source_id_node); evaluableNodeManager->FreeNodeTreeIfPossible(source_id_node); - if(immediate_result) - return EvaluableNodeReference(source_entity != nullptr); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(source_entity != nullptr ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(source_entity != nullptr, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINED_ENTITIES_and_COMPUTE_ON_CONTAINED_ENTITIES(EvaluableNode *en, bool immediate_result) @@ -211,10 +209,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_LABEL(EvaluableNo if(target_entity != curEntity && Entity::IsLabelPrivate(label_sid)) return EvaluableNodeReference::Null(); - bool contains_label = target_entity->DoesLabelExist(label_sid); - if(immediate_result) - return EvaluableNodeReference(contains_label); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(contains_label ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(target_entity->DoesLabelExist(label_sid), immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_TO_ENTITIES_and_DIRECT_ASSIGN_TO_ENTITIES_and_ACCUM_TO_ENTITIES(EvaluableNode *en, bool immediate_result) @@ -305,9 +300,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_TO_ENTITIES_and_DIR return EvaluableNodeReference::Null(); } - if(immediate_result) - return EvaluableNodeReference(all_assignments_successful); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_assignments_successful ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(all_assignments_successful, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_RETRIEVE_FROM_ENTITY_and_DIRECT_RETRIEVE_FROM_ENTITY(EvaluableNode *en, bool immediate_result) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp index 613bfbbc..ab401d28 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp @@ -285,16 +285,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_ROOT_PERMISSION if(!asset_manager.DoesEntityHaveRootPermission(curEntity)) return EvaluableNodeReference::Null(); - //get the id of the entity EntityReadReference entity = InterpretNodeIntoRelativeSourceEntityReadReferenceFromInterpretedEvaluableNodeIDPath(ocn[0]); - if(entity == nullptr) - return EvaluableNodeReference::Null(); - - bool has_root = asset_manager.DoesEntityHaveRootPermission(entity); - if(immediate_result) - return EvaluableNodeReference(has_root); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(has_root ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(asset_manager.DoesEntityHaveRootPermission(entity), immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_ENTITY_ROOT_PERMISSION(EvaluableNode *en, bool immediate_result) @@ -549,10 +541,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DESTROY_ENTITIES(Evaluable delete source_entity; } - if(immediate_result) - return EvaluableNodeReference(all_destroys_successful); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_destroys_successful ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(all_destroys_successful, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_LOAD(EvaluableNode *en, bool immediate_result) @@ -772,7 +761,5 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_STORE_ENTITY(EvaluableNode bool stored_successfully = asset_manager.StoreEntityToResourcePath(source_entity, resource_name, file_type, false, true, escape_filename, escape_contained_filenames, sort_keys); - if(immediate_result) - return EvaluableNodeReference(stored_successfully); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(stored_successfully ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(stored_successfully, immediate_result); } diff --git a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp index 80898bb9..3d3701d9 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp @@ -151,11 +151,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_XOR(EvaluableNode *en, boo //if an odd number of true arguments, then return true bool result = (num_true % 2 == 1); - - if(immediate_result) - return EvaluableNodeReference(result); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(result ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(result, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_NOT(EvaluableNode *en, bool immediate_result) @@ -335,9 +331,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NEQUAL(EvaluableNode *en, for(size_t i = 0; i < values.size(); i++) evaluableNodeManager->FreeNodeTreeIfPossible(values[i]); - if(immediate_result) - return EvaluableNodeReference(all_not_equal); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_not_equal ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(all_not_equal, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableNode *en, bool immediate_result) @@ -655,8 +649,5 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_NEQUALS(EvaluableNode for(size_t i = 0; i < values.size(); i++) evaluableNodeManager->FreeNodeTreeIfPossible(values[i]); - if(immediate_result) - return EvaluableNodeReference(all_not_equal); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_not_equal ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(all_not_equal, immediate_result); } diff --git a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp index 793c124a..bf6e9f9e 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp @@ -35,14 +35,14 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ADD(EvaluableNode *en, boo for(auto &cn : interpreted_nodes) value += EvaluableNode::ToNumber(cn); - return AllocNumberReturn(value, immediate_result); + return AllocReturn(value, immediate_result); } #endif for(auto &cn : ocn) value += InterpretNodeIntoNumberValue(cn); - return AllocNumberReturn(value, immediate_result); + return AllocReturn(value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en, bool immediate_result) @@ -59,7 +59,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en for(size_t i = 1; i < ocn.size(); i++) value -= EvaluableNode::ToNumber(interpreted_nodes[i]); - return AllocNumberReturn(value, immediate_result); + return AllocReturn(value, immediate_result); } #endif @@ -71,7 +71,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBTRACT(EvaluableNode *en if(ocn.size() == 1) value = -value; - return AllocNumberReturn(value, immediate_result); + return AllocReturn(value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_MULTIPLY(EvaluableNode *en, bool immediate_result) @@ -89,14 +89,14 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MULTIPLY(EvaluableNode *en for(auto &cn : interpreted_nodes) value *= EvaluableNode::ToNumber(cn); - return AllocNumberReturn(value, immediate_result); + return AllocReturn(value, immediate_result); } #endif for(auto &cn : ocn) value *= InterpretNodeIntoNumberValue(cn); - return AllocNumberReturn(value, immediate_result); + return AllocReturn(value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en, bool immediate_result) @@ -129,7 +129,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en, } } - return AllocNumberReturn(value, immediate_result); + return AllocReturn(value, immediate_result); } #endif @@ -153,7 +153,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DIVIDE(EvaluableNode *en, } } - return AllocNumberReturn(value, immediate_result); + return AllocReturn(value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_MODULUS(EvaluableNode *en, bool immediate_result) @@ -173,7 +173,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MODULUS(EvaluableNode *en, value = std::fmod(value, mod); } - return AllocNumberReturn(value, immediate_result); + return AllocReturn(value, immediate_result); } #endif @@ -184,7 +184,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MODULUS(EvaluableNode *en, value = std::fmod(value, mod); } - return AllocNumberReturn(value, immediate_result); + return AllocReturn(value, immediate_result); } //helper method for InterpretNode_ENT_GET_DIGITS and InterpretNode_ENT_SET_DIGITS @@ -348,7 +348,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_DIGITS(EvaluableNode * digits = InterpretNodeForImmediateUse(ocn[2]); if(digits == nullptr || digits->GetType() != ENT_LIST) - return AllocNumberReturn(value, immediate_result); + return AllocReturn(value, immediate_result); bool negative = (value < 0); if(negative) @@ -428,7 +428,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_DIGITS(EvaluableNode * if(negative) result_value = -result_value; - return AllocNumberReturn(result_value, immediate_result); + return AllocReturn(result_value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_FLOOR(EvaluableNode *en, bool immediate_result) @@ -670,7 +670,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ATAN(EvaluableNode *en, bo { double f1 = InterpretNodeIntoNumberValue(ocn[0]); double f2 = InterpretNodeIntoNumberValue(ocn[1]); - return AllocNumberReturn(std::atan2(f1, f2), immediate_result); + return AllocReturn(std::atan2(f1, f2), immediate_result); } return EvaluableNodeReference::Null(); } @@ -855,7 +855,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_POW(EvaluableNode *en, boo double f1 = InterpretNodeIntoNumberValue(ocn[0]); double f2 = InterpretNodeIntoNumberValue(ocn[1]); - return AllocNumberReturn(std::pow(f1, f2), immediate_result); + return AllocReturn(std::pow(f1, f2), immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ABS(EvaluableNode *en, bool immediate_result) From 380d560390e045a292cb59f99196cae02492404e Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 10:27:25 -0500 Subject: [PATCH 43/55] 18652: More cleanup --- src/Amalgam/Parser.cpp | 2 +- src/Amalgam/evaluablenode/EvaluableNodeManagement.h | 7 ------- src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp | 2 +- src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp | 2 +- 4 files changed, 3 insertions(+), 10 deletions(-) diff --git a/src/Amalgam/Parser.cpp b/src/Amalgam/Parser.cpp index fd4f1a6c..ea2734d1 100644 --- a/src/Amalgam/Parser.cpp +++ b/src/Amalgam/Parser.cpp @@ -199,7 +199,7 @@ EvaluableNode *Parser::GetCodeForPathFromAToB(UnparseData &upd, EvaluableNode *a //build code to get the reference EvaluableNode *refpath = upd.enm->AllocNode(ENT_TARGET); - refpath->AppendOrderedChildNode(upd.enm->AllocNode(a_ancestor_depth)); + refpath->AppendOrderedChildNode(upd.enm->AllocNode(static_cast(a_ancestor_depth))); //combine together while(b_path_nodes.size() > 0) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index e62221c1..8e316ab2 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -234,13 +234,6 @@ class EvaluableNodeManager return n; } - inline EvaluableNode *AllocNode(int64_t int_value) - { - EvaluableNode *n = AllocUninitializedNode(); - n->InitializeType(static_cast(int_value)); - return n; - } - inline EvaluableNode *AllocNode(bool bool_value) { EvaluableNode *n = AllocUninitializedNode(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp b/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp index fbe94c64..b6529305 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp @@ -88,7 +88,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COMMONALITY(EvaluableNode size_t s1_len = 0; size_t s2_len = 0; auto edit_distance = EvaluableNodeTreeManipulation::EditDistance(ocn[0]->GetStringValue(), ocn[1]->GetStringValue(), s1_len, s2_len); - auto commonality = static_cast(std::max(s1_len, s2_len) - edit_distance); + auto commonality = static_cast(std::max(s1_len, s2_len) - edit_distance); return EvaluableNodeReference(evaluableNodeManager->AllocNode(commonality), true); } diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index f75b3797..d7758540 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -1391,7 +1391,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SPLIT(EvaluableNode *en, b } //TODO 18652: evaluate InterpretNode_* below for immediate returns -//TODO 18652: expand AllocReturn to include reusing 1 or 2 nodes, as well as handling string types (may need to remove the int/size variant of AllocNode) +//TODO 18652: expand AllocReturn to include reusing 1 or 2 nodes, as well as handling string types //TODO 18652: consider lambda function to make single value mathematical opcodes more compact EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, bool immediate_result) { From a7bfba747b2136bfb4f0f15d622c8525ba9951bf Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 10:51:52 -0500 Subject: [PATCH 44/55] 18652: Adds new AllocNode types for strings --- .../evaluablenode/EvaluableNodeManagement.h | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index 8e316ab2..06a0ed68 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -207,6 +207,13 @@ class EvaluableNodeManager return n; } + inline EvaluableNode *AllocNode(const std::string &string_value) + { + EvaluableNode *n = AllocUninitializedNode(); + n->InitializeType(ENT_STRING, string_value); + return n; + } + inline EvaluableNode *AllocNode(EvaluableNodeType type, StringInternPool::StringID string_id) { EvaluableNode *n = AllocUninitializedNode(); @@ -214,6 +221,13 @@ class EvaluableNodeManager return n; } + inline EvaluableNode *AllocNode(StringInternPool::StringID string_id) + { + EvaluableNode *n = AllocUninitializedNode(); + n->InitializeType(ENT_STRING, string_id); + return n; + } + //like AllocNode, but hands off the string reference to string_id inline EvaluableNode *AllocNodeWithReferenceHandoff(EvaluableNodeType type, StringInternPool::StringID string_id) { From 85066092a9bf447cde654fdaa63488ed4927e039 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 13:09:16 -0500 Subject: [PATCH 45/55] 18652: More prep for cleanup --- .../evaluablenode/EvaluableNodeManagement.h | 51 +++++++++++++++++++ src/Amalgam/interpreter/Interpreter.h | 30 +++++++++++ .../interpreter/InterpreterOpcodesBase.cpp | 9 +--- 3 files changed, 82 insertions(+), 8 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index 06a0ed68..0fba0fa6 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -333,6 +333,30 @@ class EvaluableNodeManager } } + //like ReuseOrAllocNode but allocates an ENT_NUMBER + inline EvaluableNodeReference ReuseOrAllocNode(EvaluableNodeReference candidate, double value) + { + EvaluableNodeReference node = ReuseOrAllocNode(candidate, ENT_NUMBER); + node->SetNumberValue(value); + return node; + } + + //like ReuseOrAllocNode but allocates an ENT_STRING + inline EvaluableNodeReference ReuseOrAllocNode(EvaluableNodeReference candidate, StringInternPool::StringID value) + { + EvaluableNodeReference node = ReuseOrAllocNode(candidate, ENT_STRING); + node->SetStringID(value); + return node; + } + + //like ReuseOrAllocNode but allocates an ENT_STRING + inline EvaluableNodeReference ReuseOrAllocNode(EvaluableNodeReference candidate, const std::string &value) + { + EvaluableNodeReference node = ReuseOrAllocNode(candidate, ENT_STRING); + node->SetStringValue(value); + return node; + } + //like ReuseOrAllocNode, but picks whichever node is reusable and frees the other if possible //will try candidate_1 first inline EvaluableNodeReference ReuseOrAllocOneOfNodes( @@ -348,6 +372,33 @@ class EvaluableNodeManager return ReuseOrAllocNode(candidate_2, type); } + //like ReuseOrAllocOneOfNodes but allocates an ENT_NUMBER + inline EvaluableNodeReference ReuseOrAllocOneOfNodes( + EvaluableNodeReference candidate_1, EvaluableNodeReference candidate_2, double value) + { + EvaluableNodeReference node = ReuseOrAllocOneOfNodes(candidate_1, candidate_2, ENT_NUMBER); + node->SetNumberValue(value); + return node; + } + + //like ReuseOrAllocOneOfNodes but allocates an ENT_STRING + inline EvaluableNodeReference ReuseOrAllocOneOfNodes( + EvaluableNodeReference candidate_1, EvaluableNodeReference candidate_2, StringInternPool::StringID value) + { + EvaluableNodeReference node = ReuseOrAllocOneOfNodes(candidate_1, candidate_2, ENT_STRING); + node->SetStringID(value); + return node; + } + + //like ReuseOrAllocOneOfNodes but allocates an ENT_STRING + inline EvaluableNodeReference ReuseOrAllocOneOfNodes( + EvaluableNodeReference candidate_1, EvaluableNodeReference candidate_2, const std::string &value) + { + EvaluableNodeReference node = ReuseOrAllocOneOfNodes(candidate_1, candidate_2, ENT_STRING); + node->SetStringValue(value); + return node; + } + //Copies the data structure and everything underneath it, modifying labels as specified // if cycle_free is true on input, then it can perform a faster copy inline EvaluableNodeReference DeepAllocCopy(EvaluableNode *tree, EvaluableNodeMetadataModifier metadata_modifier = ENMM_NO_CHANGE) diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index 075f6d6c..8e306597 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -304,6 +304,36 @@ class Interpreter return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); } + //like AllocReturn, but if immediate_result, then it will attempt to free candidate, + //and if not immediate_result, will attempt to reuse candidate + template + inline EvaluableNodeReference ReuseOrAllocReturn(EvaluableNodeReference candidate, T value, bool immediate_result) + { + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(candidate); + return EvaluableNodeReference(value); + } + + return evaluableNodeManager->ReuseOrAllocNode(candidate, value); + } + + //like ReuseOrAllocReturn, but if immediate_result, then it will attempt to free both candidates, + //and if not immediate_result, will attempt to reuse one of the candidates and free the other + template + inline EvaluableNodeReference ReuseOrAllocOneOfReturn( + EvaluableNodeReference candidate_1, EvaluableNodeReference candidate_2, T value, bool immediate_result) + { + if(immediate_result) + { + evaluableNodeManager->FreeNodeTreeIfPossible(candidate_1); + evaluableNodeManager->FreeNodeTreeIfPossible(candidate_2); + return EvaluableNodeReference(value); + } + + return evaluableNodeManager->ReuseOrAllocOneOfNodes(candidate_1, candidate_2, value); + } + //if n is immediate, it just returns it, otherwise calls InterpretNode __forceinline EvaluableNodeReference InterpretNodeForImmediateUse(EvaluableNode *n, bool immediate_result = false) { diff --git a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp index c828e9fd..8212b4b0 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp @@ -284,14 +284,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_UNPARSE(EvaluableNode *en, auto tree = InterpretNodeForImmediateUse(ocn[0]); std::string s = Parser::Unparse(tree, evaluableNodeManager, pretty, true, deterministic_order); - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(tree); - return EvaluableNodeReference(s); - } - EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(tree, ENT_STRING); - result->SetStringValue(s); - return result; + return ReuseOrAllocReturn(tree, s, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_IF(EvaluableNode *en, bool immediate_result) From 9850f3528b49c0ed77c79e759169ae120a5b32b9 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 13:25:29 -0500 Subject: [PATCH 46/55] 18652: More progress --- .../evaluablenode/EvaluableNodeManagement.h | 8 +++- src/Amalgam/interpreter/Interpreter.h | 8 +++- .../interpreter/InterpreterOpcodesBase.cpp | 29 +++++--------- .../InterpreterOpcodesDataTypes.cpp | 39 +++---------------- .../InterpreterOpcodesEntityControl.cpp | 4 +- 5 files changed, 27 insertions(+), 61 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index 0fba0fa6..954cd915 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -344,8 +344,10 @@ class EvaluableNodeManager //like ReuseOrAllocNode but allocates an ENT_STRING inline EvaluableNodeReference ReuseOrAllocNode(EvaluableNodeReference candidate, StringInternPool::StringID value) { + //perform a handoff in case candidate is the only value + string_intern_pool.CreateStringReference(value); EvaluableNodeReference node = ReuseOrAllocNode(candidate, ENT_STRING); - node->SetStringID(value); + node->SetStringIDWithReferenceHandoff(value); return node; } @@ -385,8 +387,10 @@ class EvaluableNodeManager inline EvaluableNodeReference ReuseOrAllocOneOfNodes( EvaluableNodeReference candidate_1, EvaluableNodeReference candidate_2, StringInternPool::StringID value) { + //perform a handoff in case one of the candidates is the only value + string_intern_pool.CreateStringReference(value); EvaluableNodeReference node = ReuseOrAllocOneOfNodes(candidate_1, candidate_2, ENT_STRING); - node->SetStringID(value); + node->SetStringIDWithReferenceHandoff(value); return node; } diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index 8e306597..938f8b04 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -311,8 +311,10 @@ class Interpreter { if(immediate_result) { + //need to allocate the result first just in case candidate is the only location of an interned value + EvaluableNodeReference result(value); evaluableNodeManager->FreeNodeTreeIfPossible(candidate); - return EvaluableNodeReference(value); + return result; } return evaluableNodeManager->ReuseOrAllocNode(candidate, value); @@ -326,9 +328,11 @@ class Interpreter { if(immediate_result) { + //need to allocate the result first just in case one of the candidates is the only location of an interned value + EvaluableNodeReference result(value); evaluableNodeManager->FreeNodeTreeIfPossible(candidate_1); evaluableNodeManager->FreeNodeTreeIfPossible(candidate_2); - return EvaluableNodeReference(value); + return result; } return evaluableNodeManager->ReuseOrAllocOneOfNodes(candidate_1, candidate_2, value); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp index 8212b4b0..b4762180 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp @@ -1238,17 +1238,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_INDEX(EvaluableNod //build the index node to return EvaluableNodeImmediateValueWithType enivwt = constructionStackIndicesAndUniqueness[offset].index; if(enivwt.nodeType == ENIVT_NUMBER) - { return AllocReturn(enivwt.nodeValue.number, immediate_result); - } else if(enivwt.nodeType == ENIVT_STRING_ID) - { - if(immediate_result) - return EvaluableNodeReference(enivwt.nodeValue.stringID); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, enivwt.nodeValue.stringID), true); - } - - return EvaluableNodeReference::Null(); + return AllocReturn(enivwt.nodeValue.stringID, immediate_result); + else + return EvaluableNodeReference::Null(); } EvaluableNodeReference Interpreter::InterpretNode_ENT_CURRENT_VALUE(EvaluableNode *en, bool immediate_result) @@ -1335,11 +1329,11 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ARGS(EvaluableNode *en, bo //Generates an EvaluableNode containing a random value based on the random parameter param, using enm and random_stream // if any part of param is preserved in the return value, then can_free_param will be set to false, otherwise it will be left alone -EvaluableNodeReference GenerateRandomValueBasedOnRandParam(EvaluableNodeReference param, EvaluableNodeManager *enm, +EvaluableNodeReference GenerateRandomValueBasedOnRandParam(EvaluableNodeReference param, Interpreter *interpreter, RandomStream &random_stream, bool &can_free_param, bool immediate_result) { if(param == nullptr) - return EvaluableNodeReference(enm->AllocNode(random_stream.RandFull()), true); + return interpreter->AllocReturn(random_stream.RandFull(), immediate_result); auto &ocn = param->GetOrderedChildNodes(); if(ocn.size() > 0) @@ -1352,10 +1346,7 @@ EvaluableNodeReference GenerateRandomValueBasedOnRandParam(EvaluableNodeReferenc if(DoesEvaluableNodeTypeUseNumberData(param->GetType())) { double value = random_stream.RandFull() * param->GetNumberValueReference(); - - if(immediate_result) - return EvaluableNodeReference(value); - return EvaluableNodeReference(enm->AllocNode(value), true); + return interpreter->AllocReturn(value, immediate_result); } return EvaluableNodeReference::Null(); @@ -1398,7 +1389,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RAND(EvaluableNode *en, bo { bool can_free_param = true; EvaluableNodeReference rand_value = GenerateRandomValueBasedOnRandParam(param, - evaluableNodeManager, randomStream, can_free_param, immediate_result); + this, randomStream, can_free_param, immediate_result); if(can_free_param) evaluableNodeManager->FreeNodeTreeIfPossible(param); @@ -1461,7 +1452,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_RAND(EvaluableNode *en, bo for(size_t i = 0; i < number_to_generate; i++) { EvaluableNodeReference rand_value = GenerateRandomValueBasedOnRandParam(param, - evaluableNodeManager, randomStream, can_free_param, immediate_result); + this, randomStream, can_free_param, immediate_result); retval->AppendOrderedChildNode(rand_value); retval.UpdatePropertiesBasedOnAttachedNode(rand_value); } @@ -1845,9 +1836,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_WEIGHTED_RAND(EvaluableNod EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_RAND_SEED(EvaluableNode *en, bool immediate_result) { std::string rand_state_string = randomStream.GetState(); - if(immediate_result) - return EvaluableNodeReference(rand_state_string); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, rand_state_string), true); + return AllocReturn(rand_state_string, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_RAND_SEED(EvaluableNode *en, bool immediate_result) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index d7758540..a8e4bb7b 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -187,9 +187,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NUMBER(EvaluableNode *en, EvaluableNodeReference Interpreter::InterpretNode_ENT_STRING(EvaluableNode *en, bool immediate_result) { StringInternPool::StringID value = en->GetStringIDReference(); - if(immediate_result) - return EvaluableNodeReference(value); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, value), true); + return AllocReturn(value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SYMBOL(EvaluableNode *en, bool immediate_result) @@ -240,9 +238,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_TYPE_STRING(EvaluableN evaluableNodeManager->FreeNodeTreeIfPossible(cur); std::string type_string = GetStringFromEvaluableNodeType(type, true); - if(immediate_result) - return EvaluableNodeReference(type_string); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, type_string), true); + return AllocReturn(type_string, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_TYPE(EvaluableNode *en, bool immediate_result) @@ -580,16 +576,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FORMAT(EvaluableNode *en, string_intern_pool.DestroyStringReference(to_type); - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(to_params); - evaluableNodeManager->FreeNodeTreeIfPossible(code_value); - return EvaluableNodeReference(number_value); - } - - auto result = evaluableNodeManager->ReuseOrAllocOneOfNodes(to_params, code_value, ENT_NUMBER); - result->SetNumberValue(number_value); - return result; + return ReuseOrAllocOneOfReturn(to_params, code_value, number_value, immediate_result); } else if(to_type == ENBISI_code) { @@ -889,16 +876,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FORMAT(EvaluableNode *en, string_intern_pool.DestroyStringReference(to_type); - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(to_params); - evaluableNodeManager->FreeNodeTreeIfPossible(code_value); - return EvaluableNodeReference(string_value); - } - - auto result = evaluableNodeManager->ReuseOrAllocOneOfNodes(to_params, code_value, ENT_STRING); - result->SetStringValue(string_value); - return result; + return ReuseOrAllocOneOfReturn(to_params, code_value, string_value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_LABELS(EvaluableNode *en, bool immediate_result) @@ -1082,14 +1060,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_COMMENTS(EvaluableNode return EvaluableNodeReference::Null(); StringInternPool::StringID comments_sid = n->GetCommentsStringId(); - evaluableNodeManager->FreeNodeTreeIfPossible(n); - - if(comments_sid == StringInternPool::NOT_A_STRING_ID) - return EvaluableNodeReference::Null(); - - if(immediate_result) - return EvaluableNodeReference(comments_sid); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, comments_sid), true); + return ReuseOrAllocReturn(n, comments_sid, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_COMMENTS(EvaluableNode *en, bool immediate_result) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp index ab401d28..f71b2723 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp @@ -229,9 +229,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_RAND_SEED(Evalu std::string rand_state_string = entity->GetRandomState(); - if(immediate_result) - return EvaluableNodeReference(rand_state_string); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, rand_state_string), true); + return AllocReturn(rand_state_string, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_ENTITY_RAND_SEED(EvaluableNode *en, bool immediate_result) From 435859f189ccc2cc58253eb702bc3301aa35f4b6 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 13:44:09 -0500 Subject: [PATCH 47/55] 18652: More implementation progress --- .../evaluablenode/EvaluableNodeManagement.h | 12 ++++ .../InterpreterOpcodesEntityControl.cpp | 12 +--- .../InterpreterOpcodesListManipulation.cpp | 66 +++---------------- 3 files changed, 22 insertions(+), 68 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index 954cd915..e53ac5c6 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -359,6 +359,12 @@ class EvaluableNodeManager return node; } + //like ReuseOrAllocNode but allocates either ENT_TRUE or ENT_FALSE + inline EvaluableNodeReference ReuseOrAllocNode(EvaluableNodeReference candidate, bool value) + { + return ReuseOrAllocNode(candidate, value ? ENT_TRUE: ENT_FALSE); + } + //like ReuseOrAllocNode, but picks whichever node is reusable and frees the other if possible //will try candidate_1 first inline EvaluableNodeReference ReuseOrAllocOneOfNodes( @@ -403,6 +409,12 @@ class EvaluableNodeManager return node; } + //like ReuseOrAllocOneOfNodes but allocates either ENT_TRUE or ENT_FALSE + inline EvaluableNodeReference ReuseOrAllocOneOfNodes(EvaluableNodeReference candidate, bool value) + { + return ReuseOrAllocOneOfNodes(candidate, value ? ENT_TRUE : ENT_FALSE); + } + //Copies the data structure and everything underneath it, modifying labels as specified // if cycle_free is true on input, then it can perform a faster copy inline EvaluableNodeReference DeepAllocCopy(EvaluableNode *tree, EvaluableNodeMetadataModifier metadata_modifier = ENMM_NO_CHANGE) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp index f71b2723..e05e4661 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp @@ -636,11 +636,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LOAD_ENTITY_and_LOAD_PERSI destination_entity_parent->AddContainedEntityViaReference(loaded_entity, new_entity_id, writeListeners); if(destination_entity_parent == curEntity) - { - if(immediate_result) - return EvaluableNodeReference(static_cast(new_entity_id)); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, new_entity_id), true); - } + return AllocReturn(static_cast(new_entity_id), immediate_result); else //need to return an id path return EvaluableNodeReference(GetTraversalIDPathFromAToB(evaluableNodeManager, curEntity, loaded_entity), true); } @@ -695,11 +691,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_STORE(EvaluableNode *en, b bool successful_save = asset_manager.StoreResourcePath(to_store, resource_name, resource_base_path, file_type, evaluableNodeManager, escape_filename, sort_keys); - evaluableNodeManager->FreeNodeTreeIfPossible(to_store); - - if(immediate_result) - return EvaluableNodeReference(successful_save); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(successful_save ? ENT_TRUE : ENT_FALSE), true); + return ReuseOrAllocReturn(to_store, successful_save, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_STORE_ENTITY(EvaluableNode *en, bool immediate_result) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp index 5babfacc..2d759f04 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp @@ -80,13 +80,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en, b std::string s = string_intern_pool.GetStringFromID(sid); size_t utf8_char_length = StringManipulation::GetUTF8CharacterLength(s, 0); - - evaluableNodeManager->FreeNodeTreeIfPossible(list); - std::string substring = s.substr(0, utf8_char_length); - if(immediate_result) - return EvaluableNodeReference(substring); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, substring), true); + return ReuseOrAllocReturn(list, substring, immediate_result); } if(DoesEvaluableNodeTypeUseNumberData(list->GetType())) @@ -100,11 +95,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en, b return list; //return 1 if nonzero - evaluableNodeManager->FreeNodeTreeIfPossible(list); - - if(immediate_result) - return EvaluableNodeReference(1.0); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(1.0), true); + return ReuseOrAllocReturn(list, 1.0, immediate_result); } } @@ -218,14 +209,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAIL(EvaluableNode *en, bo size_t utf8_start_offset = StringManipulation::GetNthUTF8CharacterOffset(s, num_chars_to_drop); std::string substring = s.substr(utf8_start_offset, s.size() - utf8_start_offset); - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(list); - return EvaluableNodeReference(substring); - } - EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(list, ENT_STRING); - result->SetStringValue(substring); - return result; + return ReuseOrAllocReturn(list, substring, immediate_result); } if(DoesEvaluableNodeTypeUseNumberData(list->GetType())) @@ -235,16 +219,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAIL(EvaluableNode *en, bo if(value == 0.0) return list; - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(list); - return EvaluableNodeReference(value - 1.0); - } - - //return (value - 1.0) if nonzero - EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(list, ENT_NUMBER); - result->SetNumberValue(value - 1.0); - return result; + return ReuseOrAllocReturn(list, value - 1.0, immediate_result); } } @@ -318,14 +293,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LAST(EvaluableNode *en, bo auto [utf8_char_start_offset, utf8_char_length] = StringManipulation::GetLastUTF8CharacterOffsetAndLength(s); std::string substring = s.substr(utf8_char_start_offset, utf8_char_length); - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(list); - return EvaluableNodeReference(substring); - } - EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(list, ENT_STRING); - result->SetStringValue(substring); - return result; + return ReuseOrAllocReturn(list, substring, immediate_result); } if(DoesEvaluableNodeTypeUseNumberData(list->GetType())) @@ -335,16 +303,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LAST(EvaluableNode *en, bo if(value == 0.0) return list; - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(list); - return EvaluableNodeReference(1.0); - } - - //return 1 if nonzero - EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocNode(list, ENT_NUMBER); - result->SetNumberValue(1.0); - return result; + return ReuseOrAllocReturn(list, 1.0, immediate_result); } } @@ -471,12 +430,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUNC(EvaluableNode *en, b return list; //return (value - 1.0) if nonzero - evaluableNodeManager->FreeNodeTreeIfPossible(list); - - if(immediate_result) - return EvaluableNodeReference(value - 1.0); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value - 1.0), true); + return ReuseOrAllocReturn(list, value - 1.0, immediate_result); } } @@ -594,13 +548,9 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SIZE(EvaluableNode *en, bo { size = cur->GetNumChildNodes(); } - - evaluableNodeManager->FreeNodeTreeIfPossible(cur); } - if(immediate_result) - return EvaluableNodeReference(static_cast(size)); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(static_cast(size)), true); + return ReuseOrAllocReturn(cur, static_cast(size), immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_RANGE(EvaluableNode *en, bool immediate_result) From 664379129d8ad0d5eb6d7cb4514f211b8ec3698d Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 13:55:15 -0500 Subject: [PATCH 48/55] 18652: More progress --- .../evaluablenode/EvaluableNodeManagement.h | 5 +- .../InterpreterOpcodesListManipulation.cpp | 7 +- .../interpreter/InterpreterOpcodesLogic.cpp | 108 +++--------------- 3 files changed, 18 insertions(+), 102 deletions(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index e53ac5c6..f6c8977c 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -410,9 +410,10 @@ class EvaluableNodeManager } //like ReuseOrAllocOneOfNodes but allocates either ENT_TRUE or ENT_FALSE - inline EvaluableNodeReference ReuseOrAllocOneOfNodes(EvaluableNodeReference candidate, bool value) + inline EvaluableNodeReference ReuseOrAllocOneOfNodes( + EvaluableNodeReference candidate_1, EvaluableNodeReference candidate_2, bool value) { - return ReuseOrAllocOneOfNodes(candidate, value ? ENT_TRUE : ENT_FALSE); + return ReuseOrAllocOneOfNodes(candidate_1, candidate_2, value ? ENT_TRUE : ENT_FALSE); } //Copies the data structure and everything underneath it, modifying labels as specified diff --git a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp index 2d759f04..98c59dbb 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp @@ -413,13 +413,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUNC(EvaluableNode *en, b //remove everything after after this length size_t utf8_end_offset = StringManipulation::GetNthUTF8CharacterOffset(s, num_chars_to_keep); - - evaluableNodeManager->FreeNodeTreeIfPossible(list); - std::string substring = s.substr(0, utf8_end_offset); - if(immediate_result) - return EvaluableNodeReference(substring); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, substring), true); + return ReuseOrAllocReturn(list, substring, immediate_result); } if(DoesEvaluableNodeTypeUseNumberData(list->GetType())) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp index 3d3701d9..36a23854 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp @@ -54,15 +54,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_AND(EvaluableNode *en, boo cur = InterpretNode(cn); if(!EvaluableNode::IsTrue(cur)) - { - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(cur); - return EvaluableNodeReference(false); - } - - return evaluableNodeManager->ReuseOrAllocNode(cur, ENT_FALSE); - } + return ReuseOrAllocReturn(cur, false, immediate_result); } return cur; @@ -107,12 +99,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_OR(EvaluableNode *en, bool return cur; } - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(cur); - return EvaluableNodeReference(false); - } - return evaluableNodeManager->ReuseOrAllocNode(cur, ENT_FALSE); + return ReuseOrAllocReturn(cur, false, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_XOR(EvaluableNode *en, bool immediate_result) @@ -163,13 +150,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NOT(EvaluableNode *en, boo auto cur = InterpretNodeForImmediateUse(ocn[0]); bool is_true = EvaluableNode::IsTrue(cur); - - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(cur); - return EvaluableNodeReference(!is_true); - } - return evaluableNodeManager->ReuseOrAllocNode(cur, is_true ? ENT_FALSE : ENT_TRUE); + return ReuseOrAllocReturn(cur, !is_true, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_EQUAL(EvaluableNode *en, bool immediate_result) @@ -222,26 +203,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EQUAL(EvaluableNode *en, b } if(!EvaluableNode::AreDeepEqual(to_match, cur)) - { - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(to_match); - evaluableNodeManager->FreeNodeTreeIfPossible(cur); - return EvaluableNodeReference(false); - } - - return evaluableNodeManager->ReuseOrAllocOneOfNodes(to_match, cur, ENT_FALSE); - } + return ReuseOrAllocOneOfReturn(to_match, cur, false, immediate_result); evaluableNodeManager->FreeNodeTreeIfPossible(cur); } - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(to_match); - return EvaluableNodeReference(true); - } - return evaluableNodeManager->ReuseOrAllocNode(to_match, ENT_TRUE); + return ReuseOrAllocReturn(to_match, true, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_NEQUAL(EvaluableNode *en, bool immediate_result) @@ -289,14 +256,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NEQUAL(EvaluableNode *en, EvaluableNodeReference b = InterpretNodeForImmediateUse(ocn[1]); bool a_b_not_equal = (!EvaluableNode::AreDeepEqual(a, b)); - - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(a); - evaluableNodeManager->FreeNodeTreeIfPossible(b); - return EvaluableNodeReference(a_b_not_equal); - } - return evaluableNodeManager->ReuseOrAllocOneOfNodes(a, b, a_b_not_equal ? ENT_TRUE : ENT_FALSE); + return ReuseOrAllocOneOfReturn(a, b, a_b_not_equal, immediate_result); } auto node_stack = CreateInterpreterNodeStackStateSaver(); @@ -397,16 +357,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableN auto cur = InterpretNodeForImmediateUse(ocn[i]); if(EvaluableNode::IsEmptyNode(cur) - || !EvaluableNode::IsLessThan(prev, cur, en->GetType() == ENT_LEQUAL)) - { - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - return EvaluableNodeReference(false); - } - - return evaluableNodeManager->ReuseOrAllocOneOfNodes(prev, cur, ENT_FALSE); - } + || !EvaluableNode::IsLessThan(prev, cur, en->GetType() == ENT_LEQUAL)) + return ReuseOrAllocOneOfReturn(prev, cur, false, immediate_result); evaluableNodeManager->FreeNodeTreeIfPossible(prev); prev = cur; @@ -416,12 +368,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableN } //nothing is out of order - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - return EvaluableNodeReference(true); - } - return evaluableNodeManager->ReuseOrAllocNode(prev, ENT_TRUE); + return ReuseOrAllocReturn(prev, true, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(EvaluableNode *en, bool immediate_result) @@ -487,16 +434,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab auto cur = InterpretNodeForImmediateUse(ocn[i]); if(EvaluableNode::IsEmptyNode(cur) - || !EvaluableNode::IsLessThan(cur, prev, en->GetType() == ENT_GEQUAL)) - { - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - return EvaluableNodeReference(false); - } - - return evaluableNodeManager->ReuseOrAllocOneOfNodes(prev, cur, ENT_FALSE); - } + || !EvaluableNode::IsLessThan(cur, prev, en->GetType() == ENT_GEQUAL)) + return ReuseOrAllocOneOfReturn(prev, cur, false, immediate_result); evaluableNodeManager->FreeNodeTreeIfPossible(prev); prev = cur; @@ -506,12 +445,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab } //nothing is out of order - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(prev); - return EvaluableNodeReference(true); - } - return evaluableNodeManager->ReuseOrAllocNode(prev, ENT_TRUE); + return ReuseOrAllocReturn(prev, true, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_EQUALS(EvaluableNode *en, bool immediate_result) @@ -585,26 +519,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_EQUALS(EvaluableNode to_match_type = to_match->GetType(); if(cur_type != to_match_type) - { - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(to_match); - evaluableNodeManager->FreeNodeTreeIfPossible(cur); - return EvaluableNodeReference(false); - } - - return evaluableNodeManager->ReuseOrAllocOneOfNodes(to_match, cur, ENT_FALSE); - } + return ReuseOrAllocOneOfReturn(to_match, cur, false, immediate_result); evaluableNodeManager->FreeNodeTreeIfPossible(cur); } - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(to_match); - return EvaluableNodeReference(true); - } - return evaluableNodeManager->ReuseOrAllocNode(to_match, ENT_TRUE); + return ReuseOrAllocReturn(to_match, true, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_NEQUALS(EvaluableNode *en, bool immediate_result) From 477e6df5685fea8ae427624877599c85f7e23c4a Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 14:02:14 -0500 Subject: [PATCH 49/55] 18652: More implementation --- .../interpreter/InterpreterOpcodesMath.cpp | 42 ++----------------- .../InterpreterOpcodesTransformations.cpp | 18 +------- 2 files changed, 6 insertions(+), 54 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp index bf6e9f9e..48183493 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp @@ -514,11 +514,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en, b } } - if(immediate_result) - return EvaluableNodeReference(number_value); - - retval->SetNumberValue(number_value); - return retval; + return ReuseOrAllocReturn(retval, number_value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_EXPONENT(EvaluableNode *en, bool immediate_result) @@ -1067,16 +1063,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DOT_PRODUCT(EvaluableNode } } - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(elements1); - evaluableNodeManager->FreeNodeTreeIfPossible(elements2); - return EvaluableNodeReference(dot_product); - } - - EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocOneOfNodes(elements1, elements2, ENT_NUMBER); - result->SetNumberValue(dot_product); - return result; + return ReuseOrAllocOneOfReturn(elements1, elements2, dot_product, immediate_result); } //builds a vector of the values in the node, using ordered or mapped child nodes as appropriate @@ -1245,18 +1232,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GENERALIZED_DISTANCE(Evalu } double value = dist_params.ComputeMinkowskiDistance(location, location_types, origin, origin_types, true); - - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(location_node); - evaluableNodeManager->FreeNodeTreeIfPossible(origin_node); - return EvaluableNodeReference(value); - } - - //free these after computation in case they had any code being used/referenced in the distance - EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocOneOfNodes(location_node, origin_node, ENT_NUMBER); - result->SetNumberValue(value); - return result; + return ReuseOrAllocOneOfReturn(location_node, origin_node, value, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ENTROPY(EvaluableNode *en, bool immediate_result) @@ -1476,15 +1452,5 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ENTROPY(EvaluableNode *en, //are larger than the values in p, the resulting value may wind up being a tiny negative, but since information gain cannot be negative, //we take the max of the result and 0 accumulated_entropy = std::max(0.0, accumulated_entropy); - - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(p_node); - evaluableNodeManager->FreeNodeTreeIfPossible(q_node); - return EvaluableNodeReference(accumulated_entropy); - } - - EvaluableNodeReference result = evaluableNodeManager->ReuseOrAllocOneOfNodes(p_node, q_node, ENT_NUMBER); - result->SetNumberValue(accumulated_entropy); - return result; + return ReuseOrAllocOneOfReturn(p_node, q_node, accumulated_entropy, immediate_result); } diff --git a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp index cd6b71d2..04708b8d 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp @@ -1048,14 +1048,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_INDEX(EvaluableNo EvaluableNode **target = TraverseToDestinationFromTraversalPathList(&container.GetReference(), index, false); bool found = (target != nullptr); - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(index); - evaluableNodeManager->FreeNodeTreeIfPossible(container); - return EvaluableNodeReference(found); - } - - return evaluableNodeManager->ReuseOrAllocOneOfNodes(index, container, found ? ENT_TRUE : ENT_FALSE); + return ReuseOrAllocOneOfReturn(index, container, found, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_VALUE(EvaluableNode *en, bool immediate_result) @@ -1123,14 +1116,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_VALUE(EvaluableNo found = true; } - if(immediate_result) - { - evaluableNodeManager->FreeNodeTreeIfPossible(value); - evaluableNodeManager->FreeNodeTreeIfPossible(container); - return EvaluableNodeReference(found); - } - - return evaluableNodeManager->ReuseOrAllocOneOfNodes(value, container, found ? ENT_TRUE : ENT_FALSE); + return ReuseOrAllocOneOfReturn(value, container, found, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_REMOVE(EvaluableNode *en, bool immediate_result) From 07d1ee59be14949763b15830cffccfa044f5e06a Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 14:17:40 -0500 Subject: [PATCH 50/55] 18652: More code reduction --- src/Amalgam/interpreter/Interpreter.h | 17 ++ .../InterpreterOpcodesDataTypes.cpp | 2 - .../interpreter/InterpreterOpcodesMath.cpp | 232 ++++-------------- 3 files changed, 59 insertions(+), 192 deletions(-) diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index 938f8b04..aece85d4 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -346,6 +346,23 @@ class Interpreter return InterpretNode(n, immediate_result); } + //computes a unary numeric function on the given node + __forceinline EvaluableNodeReference InterpretNodeUnaryNumericOperation(EvaluableNode *n, bool immediate_result, + std::function func) + { + if(immediate_result) + { + double value = InterpretNodeIntoNumberValue(n); + return EvaluableNodeReference(std::floor(value)); + } + + auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(n); + double value = retval->GetNumberValueReference(); + double result = func(value); + retval->SetNumberValue(result); + return retval; + } + //Calls InterpretNode on n, converts to std::string and stores in value to return, then cleans up any resources used //returns a pair of bool, whether it was a valid string (and not NaS), and the string std::pair InterpretNodeIntoStringValue(EvaluableNode *n); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index a8e4bb7b..a6dc52f0 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -1362,8 +1362,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SPLIT(EvaluableNode *en, b } //TODO 18652: evaluate InterpretNode_* below for immediate returns -//TODO 18652: expand AllocReturn to include reusing 1 or 2 nodes, as well as handling string types -//TODO 18652: consider lambda function to make single value mathematical opcodes more compact EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp index 48183493..0d095a32 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp @@ -437,15 +437,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FLOOR(EvaluableNode *en, b if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::floor(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::floor(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::floor(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_CEILING(EvaluableNode *en, bool immediate_result) @@ -454,15 +447,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CEILING(EvaluableNode *en, if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::ceil(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::ceil(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::ceil(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ROUND(EvaluableNode *en, bool immediate_result) @@ -523,15 +509,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EXPONENT(EvaluableNode *en if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::exp(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::exp(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::exp(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_LOG(EvaluableNode *en, bool immediate_result) @@ -547,15 +526,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LOG(EvaluableNode *en, boo divisor = log(log_base); } - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::log(value) / divisor); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::log(retval->GetNumberValueReference()) / divisor); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [divisor](double value) { return std::log(value) / divisor; }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SIN(EvaluableNode *en, bool immediate_result) @@ -564,15 +536,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SIN(EvaluableNode *en, boo if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::sin(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::sin(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::sin(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ASIN(EvaluableNode *en, bool immediate_result) @@ -581,15 +546,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASIN(EvaluableNode *en, bo if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::asin(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::asin(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::asin(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_COS(EvaluableNode *en, bool immediate_result) @@ -598,15 +556,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COS(EvaluableNode *en, boo if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::cos(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::cos(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::cos(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOS(EvaluableNode *en, bool immediate_result) @@ -615,15 +566,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOS(EvaluableNode *en, bo if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::acos(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::acos(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::acos(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_TAN(EvaluableNode *en, bool immediate_result) @@ -632,15 +576,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAN(EvaluableNode *en, boo if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::tan(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::tan(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::tan(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ATAN(EvaluableNode *en, bool immediate_result) @@ -652,15 +589,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ATAN(EvaluableNode *en, bo if(ocn.size() == 1) { - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::atan(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::atan(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::atan(value); }); } else if(ocn.size() >= 2) { @@ -677,15 +607,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SINH(EvaluableNode *en, bo if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::sinh(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::sinh(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::sinh(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ASINH(EvaluableNode *en, bool immediate_result) @@ -694,15 +617,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASINH(EvaluableNode *en, b if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::asinh(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::asinh(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::asinh(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_COSH(EvaluableNode *en, bool immediate_result) @@ -711,15 +627,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COSH(EvaluableNode *en, bo if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::cosh(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::cosh(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::cosh(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOSH(EvaluableNode *en, bool immediate_result) @@ -728,15 +637,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ACOSH(EvaluableNode *en, b if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::acosh(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::acosh(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::acosh(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_TANH(EvaluableNode *en, bool immediate_result) @@ -745,33 +647,18 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TANH(EvaluableNode *en, bo if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::tanh(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::tanh(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::tanh(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ATANH(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); - if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::atanh(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::atanh(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::atanh(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ERF(EvaluableNode *en, bool immediate_result) @@ -780,15 +667,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ERF(EvaluableNode *en, boo if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::erf(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::erf(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::erf(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_TGAMMA(EvaluableNode *en, bool immediate_result) @@ -797,15 +677,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TGAMMA(EvaluableNode *en, if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::tgamma(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::tgamma(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::tgamma(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_LGAMMA(EvaluableNode *en, bool immediate_result) @@ -814,15 +687,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LGAMMA(EvaluableNode *en, if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::lgamma(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::lgamma(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::lgamma(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_SQRT(EvaluableNode *en, bool immediate_result) @@ -831,15 +697,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SQRT(EvaluableNode *en, bo if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::sqrt(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::sqrt(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::sqrt(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_POW(EvaluableNode *en, bool immediate_result) @@ -860,15 +719,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ABS(EvaluableNode *en, boo if(ocn.size() == 0) return EvaluableNodeReference::Null(); - if(immediate_result) - { - double value = InterpretNodeIntoNumberValue(ocn[0]); - return EvaluableNodeReference(std::abs(value)); - } - - auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(ocn[0]); - retval->SetNumberValue(std::abs(retval->GetNumberValueReference())); - return retval; + return InterpretNodeUnaryNumericOperation(ocn[0], immediate_result, + [](double value) { return std::abs(value); }); } EvaluableNodeReference Interpreter::InterpretNode_ENT_MAX(EvaluableNode *en, bool immediate_result) From 5bd202df8d078c96fa7ce0b3a60b2e06e979ea37 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 14:35:01 -0500 Subject: [PATCH 51/55] 18652: More cleanup --- src/Amalgam/interpreter/Interpreter.cpp | 10 ++-- src/Amalgam/interpreter/Interpreter.h | 2 +- .../InterpreterOpcodesDataTypes.cpp | 46 ++++++++----------- 3 files changed, 26 insertions(+), 32 deletions(-) diff --git a/src/Amalgam/interpreter/Interpreter.cpp b/src/Amalgam/interpreter/Interpreter.cpp index 27ea16cf..41e3c312 100644 --- a/src/Amalgam/interpreter/Interpreter.cpp +++ b/src/Amalgam/interpreter/Interpreter.cpp @@ -609,19 +609,19 @@ StringInternPool::StringID Interpreter::InterpretNodeIntoStringIDValueWithRefere } } -EvaluableNode *Interpreter::InterpretNodeIntoUniqueStringIDValueEvaluableNode(EvaluableNode *n) +EvaluableNodeReference Interpreter::InterpretNodeIntoUniqueStringIDValueEvaluableNode(EvaluableNode *n) { //if can skip InterpretNode, then just allocate the string if(n == nullptr || n->GetIsIdempotent() || n->GetType() == ENT_STRING || n->GetType() == ENT_NUMBER) - return evaluableNodeManager->AllocNodeWithReferenceHandoff(ENT_STRING, - EvaluableNode::ToStringIDWithReference(n)); + return EvaluableNodeReference(evaluableNodeManager->AllocNodeWithReferenceHandoff(ENT_STRING, + EvaluableNode::ToStringIDWithReference(n)), true); auto result = InterpretNode(n); if(result == nullptr || !result.unique) - return evaluableNodeManager->AllocNodeWithReferenceHandoff(ENT_STRING, - EvaluableNode::ToStringIDWithReference(result)); + return EvaluableNodeReference(evaluableNodeManager->AllocNodeWithReferenceHandoff(ENT_STRING, + EvaluableNode::ToStringIDWithReference(result)), true); result->ClearMetadata(); diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index aece85d4..d8262516 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -384,7 +384,7 @@ class Interpreter StringInternPool::StringID InterpretNodeIntoStringIDValueWithReference(EvaluableNode *n); //Calls InterpnetNode on n, convers to a string, and makes sure that the node returned is new and unique so that it can be modified - EvaluableNode *InterpretNodeIntoUniqueStringIDValueEvaluableNode(EvaluableNode *n); + EvaluableNodeReference InterpretNodeIntoUniqueStringIDValueEvaluableNode(EvaluableNode *n); //Calls InterpretNode on n, converts to double and returns, then cleans up any resources used double InterpretNodeIntoNumberValue(EvaluableNode *n); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index a6dc52f0..fb551bd9 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -1238,7 +1238,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SPLIT(EvaluableNode *en, b //if only one element, nothing to split on, just return the string in a list if(ocn.size() == 1) { - EvaluableNode *str_node = InterpretNodeIntoUniqueStringIDValueEvaluableNode(ocn[0]); + auto str_node = InterpretNodeIntoUniqueStringIDValueEvaluableNode(ocn[0]); retval->AppendOrderedChildNode(str_node); return retval; } @@ -1361,7 +1361,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SPLIT(EvaluableNode *en, b return retval; } -//TODO 18652: evaluate InterpretNode_* below for immediate returns EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, bool immediate_result) { auto &ocn = en->GetOrderedChildNodes(); @@ -1371,15 +1370,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, //if only string as the parameter, just return a new copy of the string if(ocn.size() == 1) - { - return EvaluableNodeReference(evaluableNodeManager->AllocNodeWithReferenceHandoff(ENT_STRING, - EvaluableNode::ToStringIDWithReference(ocn[0])), true); - } + return InterpretNodeIntoUniqueStringIDValueEvaluableNode(ocn[0]); //have at least 2 params auto [valid_string_to_substr, string_to_substr] = InterpretNodeIntoStringValue(ocn[0]); if(!valid_string_to_substr) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, string_intern_pool.NOT_A_STRING_ID), true); + return AllocReturn(string_intern_pool.NOT_A_STRING_ID, immediate_result); bool replace_string = false; std::string replacement_string; @@ -1391,7 +1387,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, std::swap(replacement_string, temp_replacement_string); if(!valid_replacement_string) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, string_intern_pool.NOT_A_STRING_ID), true); + return AllocReturn(string_intern_pool.NOT_A_STRING_ID, immediate_result); } EvaluableNodeReference substr_node = InterpretNodeForImmediateUse(ocn[1]); @@ -1481,7 +1477,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, if(end_offset < string_to_substr.size()) rebuilt_string += string_to_substr.substr(end_offset); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, rebuilt_string), true); + return AllocReturn(rebuilt_string, immediate_result); } else //return just the substring { @@ -1489,7 +1485,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, if(start_offset < string_to_substr.size() && end_offset > start_offset) substr = string_to_substr.substr(start_offset, end_offset - start_offset); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, substr), true); + return AllocReturn(substr, immediate_result); } } else if(substr_node->GetType() == ENT_STRING) @@ -1517,7 +1513,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, catch(...) { //bad regex, so nothing was replaced, just return original - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, string_to_substr), true); + return AllocReturn(string_to_substr, immediate_result); } std::string updated_string; @@ -1544,7 +1540,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, out = std::copy(last_iter->suffix().first, last_iter->suffix().second, out); } - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, updated_string), true); + return AllocReturn(updated_string, immediate_result); } else //finding matches { @@ -1610,7 +1606,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, catch(...) { //bad regex, return same as not found - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, string_intern_pool.NOT_A_STRING_ID), true); + return AllocReturn(string_intern_pool.NOT_A_STRING_ID, immediate_result); } std::sregex_token_iterator iter(begin(string_to_substr), end(string_to_substr), rx); @@ -1618,12 +1614,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SUBSTR(EvaluableNode *en, if(iter == rx_end) { //not found - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, string_intern_pool.NOT_A_STRING_ID), true); + return AllocReturn(string_intern_pool.NOT_A_STRING_ID, immediate_result); } else { std::string value = *iter; - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, value), true); + return AllocReturn(value, immediate_result); } } else if(full_matches) @@ -1699,14 +1695,14 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONCAT(EvaluableNode *en, //if only one parameter is specified, do a fast shortcut if(ocn.size() == 1) - return EvaluableNodeReference(InterpretNodeIntoUniqueStringIDValueEvaluableNode(ocn[0]), true); + return InterpretNodeIntoUniqueStringIDValueEvaluableNode(ocn[0]); std::string s; for(auto &cn : ocn) { auto [valid, cur_string] = InterpretNodeIntoStringValue(cn); if(!valid) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, string_intern_pool.NOT_A_STRING_ID), true); + return AllocReturn(string_intern_pool.NOT_A_STRING_ID, immediate_result); //want to exit early if out of resources because // this opcode can chew through memory with string concatenation via returned nulls @@ -1717,7 +1713,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONCAT(EvaluableNode *en, s += cur_string; } - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, s), true); + return AllocReturn(s, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_CRYPTO_SIGN(EvaluableNode *en, bool immediate_result) @@ -1731,7 +1727,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CRYPTO_SIGN(EvaluableNode std::string signature = SignMessage(message, secret_key); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, signature), true); + return AllocReturn(signature, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_CRYPTO_SIGN_VERIFY(EvaluableNode *en, bool immediate_result) @@ -1746,7 +1742,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CRYPTO_SIGN_VERIFY(Evaluab bool valid_sig = IsSignatureValid(message, public_key, signature); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(valid_sig ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(valid_sig, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_ENCRYPT(EvaluableNode *en, bool immediate_result) @@ -1774,7 +1770,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ENCRYPT(EvaluableNode *en, else //use public key encryption cyphertext = EncryptMessage(plaintext, key_1, key_2, nonce); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, cyphertext), true); + return AllocReturn(cyphertext, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_DECRYPT(EvaluableNode *en, bool immediate_result) @@ -1802,7 +1798,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DECRYPT(EvaluableNode *en, else //use public key encryption plaintext = DecryptMessage(cyphertext, key_1, key_2, nonce); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, plaintext), true); + return AllocReturn(plaintext, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_PRINT(EvaluableNode *en, bool immediate_result) @@ -1860,8 +1856,6 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TOTAL_SIZE(EvaluableNode * return EvaluableNodeReference::Null(); auto cur = InterpretNodeForImmediateUse(ocn[0]); - size_t total_size = EvaluableNode::GetDeepSize(cur); - evaluableNodeManager->FreeNodeTreeIfPossible(cur); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(static_cast(total_size)), true); + double total_size = static_cast(EvaluableNode::GetDeepSize(cur)); + return ReuseOrAllocReturn(cur, total_size, immediate_result); } \ No newline at end of file From ad025943cd7625a829db346fc4c6fb845c56972a Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 14:42:28 -0500 Subject: [PATCH 52/55] 18652: Adds space --- src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp index fb551bd9..5b0579a2 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesDataTypes.cpp @@ -1858,4 +1858,4 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TOTAL_SIZE(EvaluableNode * auto cur = InterpretNodeForImmediateUse(ocn[0]); double total_size = static_cast(EvaluableNode::GetDeepSize(cur)); return ReuseOrAllocReturn(cur, total_size, immediate_result); -} \ No newline at end of file +} From fdd84e00289729092bb8011e30df3a69df065a23 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Tue, 26 Dec 2023 14:55:46 -0500 Subject: [PATCH 53/55] 18652: Fixes bug --- src/Amalgam/interpreter/Interpreter.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Amalgam/interpreter/Interpreter.h b/src/Amalgam/interpreter/Interpreter.h index d8262516..9114d6b3 100644 --- a/src/Amalgam/interpreter/Interpreter.h +++ b/src/Amalgam/interpreter/Interpreter.h @@ -353,7 +353,7 @@ class Interpreter if(immediate_result) { double value = InterpretNodeIntoNumberValue(n); - return EvaluableNodeReference(std::floor(value)); + return EvaluableNodeReference(func(value)); } auto retval = InterpretNodeIntoUniqueNumberValueEvaluableNode(n); From da749a08aba309f45417c6a7b5c1249286ac95d2 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Wed, 27 Dec 2023 20:03:49 -0500 Subject: [PATCH 54/55] 18652: Extra cleanup in error handling and less common paths --- .../interpreter/InterpreterOpcodesBase.cpp | 25 ++++++----- .../InterpreterOpcodesCodeMixing.cpp | 20 ++++----- .../InterpreterOpcodesEntityControl.cpp | 6 +-- .../InterpreterOpcodesListManipulation.cpp | 10 ++--- .../interpreter/InterpreterOpcodesLogic.cpp | 42 ++++++++----------- .../interpreter/InterpreterOpcodesMath.cpp | 16 +++---- .../InterpreterOpcodesTransformations.cpp | 4 +- 7 files changed, 58 insertions(+), 65 deletions(-) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp index b4762180..a52667fa 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesBase.cpp @@ -87,7 +87,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM(EvaluableNode *en, if(std::cin.bad() || std::cin.eof()) exit(0); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, input), true); + return AllocReturn(input, immediate_result); } else if(command == "printline" && ocn.size() > 1) { @@ -102,7 +102,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM(EvaluableNode *en, if(ocn.size() == 1) { auto path = std::filesystem::current_path(); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, path.string()), true); + return AllocReturn(path.string(), immediate_result); } std::string directory = InterpretNodeIntoStringValueEmptyNull(ocn[1]); @@ -111,10 +111,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM(EvaluableNode *en, //try to set the directory std::error_code error; std::filesystem::current_path(directory, error); - if(error) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); - else - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_TRUE), true); + bool error_value = static_cast(error); + return AllocReturn(error_value, immediate_result); } else if(command == "system" && ocn.size() > 1) { @@ -136,7 +134,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM(EvaluableNode *en, else if(command == "os") { std::string os = Platform_GetOperatingSystemName(); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, os), true); + return AllocReturn(os, immediate_result); } else if(command == "sleep") { @@ -152,15 +150,16 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM(EvaluableNode *en, } else if(command == "version") { - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, AMALGAM_VERSION_STRING), true); + std::string version_string = AMALGAM_VERSION_STRING; + return AllocReturn(version_string, immediate_result); } else if(command == "est_mem_reserved") { - return EvaluableNodeReference(evaluableNodeManager->AllocNode(static_cast(curEntity->GetEstimatedReservedDeepSizeInBytes())), true); + return AllocReturn(static_cast(curEntity->GetEstimatedReservedDeepSizeInBytes()), immediate_result); } else if(command == "est_mem_used") { - return EvaluableNodeReference(evaluableNodeManager->AllocNode(static_cast(curEntity->GetEstimatedUsedDeepSizeInBytes())), true); + return AllocReturn(static_cast(curEntity->GetEstimatedUsedDeepSizeInBytes()), immediate_result); } else if(command == "mem_diagnostics") { @@ -169,7 +168,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM(EvaluableNode *en, auto lock = curEntity->CreateEntityLock(); #endif - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, GetEntityMemorySizeDiagnostics(curEntity)), true); + return AllocReturn(GetEntityMemorySizeDiagnostics(curEntity), immediate_result); } else if(command == "rand" && ocn.size() > 1) { @@ -181,7 +180,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM(EvaluableNode *en, std::string rand_data(num_bytes, '\0'); Platform_GenerateSecureRandomData(&rand_data[0], num_bytes); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, rand_data), true); + return AllocReturn(rand_data, immediate_result); } else if(command == "sign_key_pair") { @@ -208,7 +207,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SYSTEM(EvaluableNode *en, { uint8_t built_in_data[] = AMALGAM_BUILT_IN_DATA; std::string built_in_data_s(reinterpret_cast(&built_in_data[0]), sizeof(built_in_data)); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, built_in_data_s), true); + return AllocReturn(built_in_data_s, immediate_result); } return EvaluableNodeReference::Null(); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp b/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp index b6529305..742834b9 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesCodeMixing.cpp @@ -89,7 +89,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COMMONALITY(EvaluableNode size_t s2_len = 0; auto edit_distance = EvaluableNodeTreeManipulation::EditDistance(ocn[0]->GetStringValue(), ocn[1]->GetStringValue(), s1_len, s2_len); auto commonality = static_cast(std::max(s1_len, s2_len) - edit_distance); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(commonality), true); + return AllocReturn(commonality, immediate_result); } //otherwise, treat both as nodes and calculate node commonality @@ -104,7 +104,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COMMONALITY(EvaluableNode evaluableNodeManager->FreeNodeTreeIfPossible(tree1); evaluableNodeManager->FreeNodeTreeIfPossible(tree2); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(results.commonality), true); + return AllocReturn(results.commonality, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_EDIT_DISTANCE(EvaluableNode *en, bool immediate_result) @@ -142,7 +142,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EDIT_DISTANCE(EvaluableNod evaluableNodeManager->FreeNodeTreeIfPossible(tree1); evaluableNodeManager->FreeNodeTreeIfPossible(tree2); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(edit_distance), true); + return AllocReturn(edit_distance, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_INTERSECT(EvaluableNode *en, bool immediate_result) @@ -303,7 +303,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TOTAL_ENTITY_SIZE(Evaluabl return EvaluableNodeReference::Null(); double size = static_cast(source_entity->GetDeepSizeInNodes()); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(size), true); + return AllocReturn(size, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_FLATTEN_ENTITY(EvaluableNode *en, bool immediate_result) @@ -407,7 +407,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MUTATE_ENTITY(EvaluableNod } if(destination_entity_parent == curEntity) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, new_entity_id), true); + return AllocReturn(static_cast(new_entity_id), immediate_result); else //need to return an id list return EvaluableNodeReference(GetTraversalIDPathFromAToB(evaluableNodeManager, curEntity, new_entity), true); } @@ -431,7 +431,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_COMMONALITY_ENTITIES(Evalu return EvaluableNodeReference::Null(); auto commonality = EntityManipulation::NumberOfSharedNodes(source_entity_1, source_entity_2); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(commonality.commonality), true); + return AllocReturn(commonality.commonality, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_EDIT_DISTANCE_ENTITIES(EvaluableNode *en, bool immediate_result) @@ -453,7 +453,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_EDIT_DISTANCE_ENTITIES(Eva return EvaluableNodeReference::Null(); double edit_distance = EntityManipulation::EditDistance(source_entity_1, source_entity_2); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(edit_distance), true); + return AllocReturn(edit_distance, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_INTERSECT_ENTITIES(EvaluableNode *en, bool immediate_result) @@ -504,7 +504,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_INTERSECT_ENTITIES(Evaluab } if(destination_entity_parent == curEntity) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, new_entity_id), true); + return AllocReturn(static_cast(new_entity_id), immediate_result); else //need to return an id list return EvaluableNodeReference(GetTraversalIDPathFromAToB(evaluableNodeManager, curEntity, new_entity), true); } @@ -557,7 +557,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_UNION_ENTITIES(EvaluableNo } if(destination_entity_parent == curEntity) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, new_entity_id), true); + return AllocReturn(static_cast(new_entity_id), immediate_result); else //need to return an id list return EvaluableNodeReference(GetTraversalIDPathFromAToB(evaluableNodeManager, curEntity, new_entity), true); } @@ -654,7 +654,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_MIX_ENTITIES(EvaluableNode } if(destination_entity_parent == curEntity) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, new_entity_id), true); + return AllocReturn(static_cast(new_entity_id), immediate_result); else //need to return an id list return EvaluableNodeReference(GetTraversalIDPathFromAToB(evaluableNodeManager, curEntity, new_entity), true); } diff --git a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp index e05e4661..5a9d6c23 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesEntityControl.cpp @@ -46,7 +46,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_COMMENTS(Evalua if(label_sid == StringInternPool::NOT_A_STRING_ID) { if(!deep_comments) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, EvaluableNode::GetCommentsStringId(target_entity->GetRoot())), true); + return AllocReturn(EvaluableNode::GetCommentsStringId(target_entity->GetRoot()), immediate_result); EvaluableNodeReference retval(evaluableNodeManager->AllocNode(ENT_ASSOC), true); @@ -68,7 +68,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_COMMENTS(Evalua //has valid label if(!deep_comments) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, label_value->GetCommentsStringId()), true); + return AllocReturn(label_value->GetCommentsStringId(), immediate_result); //make sure a function based on declare that has parameters if(label_value == nullptr || label_value->GetType() != ENT_DECLARE || label_value->GetOrderedChildNodes().size() < 1) @@ -208,7 +208,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ASSIGN_ENTITY_ROOTS_and_AC #endif } - return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_assignments_successful ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(all_assignments_successful, immediate_result); } EvaluableNodeReference Interpreter::InterpretNode_ENT_GET_ENTITY_RAND_SEED(EvaluableNode *en, bool immediate_result) diff --git a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp index 98c59dbb..a2ed7f9e 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesListManipulation.cpp @@ -76,7 +76,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en, b { auto sid = list->GetStringIDReference(); if(sid <= string_intern_pool.EMPTY_STRING_ID) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, StringInternPool::NOT_A_STRING_ID), true); + return AllocReturn(StringInternPool::NOT_A_STRING_ID, immediate_result); std::string s = string_intern_pool.GetStringFromID(sid); size_t utf8_char_length = StringManipulation::GetUTF8CharacterLength(s, 0); @@ -89,7 +89,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_FIRST(EvaluableNode *en, b //return 0 if zero double value = list->GetNumberValueReference(); if(FastIsNaN(value)) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(std::numeric_limits::quiet_NaN()), true); + return AllocReturn(std::numeric_limits::quiet_NaN(), immediate_result); if(value == 0.0) return list; @@ -188,7 +188,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TAIL(EvaluableNode *en, bo { auto sid = list->GetStringIDReference(); if(sid <= string_intern_pool.EMPTY_STRING_ID) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, StringInternPool::NOT_A_STRING_ID), true); + return AllocReturn(StringInternPool::NOT_A_STRING_ID, immediate_result); std::string s = string_intern_pool.GetStringFromID(sid); @@ -286,7 +286,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LAST(EvaluableNode *en, bo { auto sid = list->GetStringIDReference(); if(sid <= string_intern_pool.EMPTY_STRING_ID) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, StringInternPool::NOT_A_STRING_ID), true); + return AllocReturn(StringInternPool::NOT_A_STRING_ID, immediate_result); std::string s = string_intern_pool.GetStringFromID(sid); @@ -393,7 +393,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TRUNC(EvaluableNode *en, b { auto sid = list->GetStringIDReference(); if(sid <= string_intern_pool.EMPTY_STRING_ID) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_STRING, StringInternPool::NOT_A_STRING_ID), true); + return AllocReturn(StringInternPool::NOT_A_STRING_ID, immediate_result); std::string s = string_intern_pool.GetStringFromID(sid); diff --git a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp index 36a23854..c74ab11d 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesLogic.cpp @@ -125,7 +125,8 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_XOR(EvaluableNode *en, boo } //if an odd number of true arguments, then return true - return EvaluableNodeReference(evaluableNodeManager->AllocNode((num_true % 2 == 1) ? ENT_TRUE : ENT_FALSE), true); + bool result = (num_true % 2 == 1); + return AllocReturn(result, immediate_result); } #endif @@ -243,7 +244,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_NEQUAL(EvaluableNode *en, for(size_t i = 0; i < interpreted_nodes.size(); i++) evaluableNodeManager->FreeNodeTreeIfPossible(interpreted_nodes[i]); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(all_not_equal ? ENT_TRUE : ENT_FALSE), true); + return AllocReturn(all_not_equal, immediate_result); } #endif @@ -303,7 +304,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableN //if none or one node, then there's no order if(ocn.size() < 2) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); + return AllocReturn(false, immediate_result); #ifdef MULTITHREAD_SUPPORT std::vector interpreted_nodes; @@ -315,11 +316,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableN for(auto &n : interpreted_nodes) evaluableNodeManager->FreeNodeTreeIfPossible(n); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); + return AllocReturn(false, immediate_result); } - EvaluableNodeType return_type = ENT_TRUE; - + bool result = true; for(size_t i = 1; i < interpreted_nodes.size(); i++) { //if not in strict increasing order, return false @@ -327,21 +327,21 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_LESS_and_LEQUAL(EvaluableN if(EvaluableNode::IsNaN(cur)) { - return_type = ENT_FALSE; + result = false; break; } if(!EvaluableNode::IsLessThan(prev, cur, en->GetType() == ENT_LEQUAL)) { - return_type = ENT_FALSE; + result = false; break; } } for(auto &n : interpreted_nodes) evaluableNodeManager->FreeNodeTreeIfPossible(n); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(return_type), true); + + return AllocReturn(result, immediate_result); } #endif @@ -380,7 +380,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab //if none or one node, then it's in order if(ocn.size() < 2) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); + return AllocReturn(false, immediate_result); #ifdef MULTITHREAD_SUPPORT std::vector interpreted_nodes; @@ -392,11 +392,10 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab for(auto &n : interpreted_nodes) evaluableNodeManager->FreeNodeTreeIfPossible(n); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); + return AllocReturn(false, immediate_result); } - EvaluableNodeType return_type = ENT_TRUE; - + bool result = true; for(size_t i = 1; i < interpreted_nodes.size(); i++) { //if not in strict increasing order, return false @@ -404,13 +403,13 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab if(EvaluableNode::IsNaN(cur)) { - return_type = ENT_FALSE; + result = false; break; } if(!EvaluableNode::IsLessThan(cur, prev, en->GetType() == ENT_GEQUAL)) { - return_type = ENT_FALSE; + result = false; break; } } @@ -418,7 +417,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_GREATER_and_GEQUAL(Evaluab for(auto &n : interpreted_nodes) evaluableNodeManager->FreeNodeTreeIfPossible(n); - return EvaluableNodeReference(evaluableNodeManager->AllocNode(return_type), true); + return AllocReturn(result, immediate_result); } #endif @@ -481,17 +480,12 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_TYPE_EQUALS(EvaluableNode to_match_type = to_match->GetType(); if(cur_type != to_match_type) - { - evaluableNodeManager->FreeNodeTreeIfPossible(to_match); - evaluableNodeManager->FreeNodeTreeIfPossible(cur); - - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); - } + return ReuseOrAllocOneOfReturn(to_match, cur, false, immediate_result); evaluableNodeManager->FreeNodeTreeIfPossible(cur); } - return evaluableNodeManager->ReuseOrAllocNode(to_match, ENT_TRUE); + return ReuseOrAllocReturn(to_match, true, immediate_result); } #endif diff --git a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp index 0d095a32..2c8740af 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesMath.cpp @@ -317,18 +317,18 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_SET_DIGITS(EvaluableNode * auto &ocn = en->GetOrderedChildNodes(); size_t num_params = ocn.size(); if(num_params == 0) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(std::numeric_limits::quiet_NaN()), true); + return AllocReturn(std::numeric_limits::quiet_NaN(), immediate_result); double value = InterpretNodeIntoNumberValue(ocn[0]); if(FastIsNaN(value) || value == std::numeric_limits::infinity()) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocReturn(value, immediate_result); double base = 10; if(num_params > 1) { base = InterpretNodeIntoNumberValue(ocn[1]); if(base <= 0) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(value), true); + return AllocReturn(value, immediate_result); } bool relative_to_zero = true; @@ -859,18 +859,18 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_DOT_PRODUCT(EvaluableNode { auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() < 2) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(0.0), true); + return AllocReturn(0.0, immediate_result); EvaluableNodeReference elements1 = InterpretNodeForImmediateUse(ocn[0]); if(EvaluableNode::IsNull(elements1)) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(0.0), true); + return AllocReturn(0.0, immediate_result); auto node_stack = CreateInterpreterNodeStackStateSaver(elements1); EvaluableNodeReference elements2 = InterpretNodeForImmediateUse(ocn[1]); node_stack.PopEvaluableNode(); if(EvaluableNode::IsNull(elements2)) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(0.0), true); + return AllocReturn(0.0, immediate_result); bool elements1_assoc = elements1->IsAssociativeArray(); bool elements2_assoc = elements2->IsAssociativeArray(); @@ -1092,7 +1092,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ENTROPY(EvaluableNode *en, auto &ocn = en->GetOrderedChildNodes(); if(ocn.size() == 0) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(0.0), true); + return AllocReturn(0.0, immediate_result); //get first list of probabilities, p bool p_is_constant = false; @@ -1207,7 +1207,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_ENTROPY(EvaluableNode *en, //if both are constants, then have no entropy (no probability mass), so return 0 if((p_is_constant || p_num_elements == std::numeric_limits::max()) && (q_is_constant || q_num_elements == std::numeric_limits::max())) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(0.0), true); + return AllocReturn(0.0, immediate_result); //now that have the size of both p and q, can compute constant values if applicable //if p_node is null then compute a constant value diff --git a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp index 04708b8d..7fa90385 100644 --- a/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp +++ b/src/Amalgam/interpreter/InterpreterOpcodesTransformations.cpp @@ -1038,7 +1038,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_INDEX(EvaluableNo //get assoc array to look up auto container = InterpretNodeForImmediateUse(ocn[0]); if(container == nullptr) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); + return AllocReturn(false, immediate_result); auto node_stack = CreateInterpreterNodeStackStateSaver(container); @@ -1062,7 +1062,7 @@ EvaluableNodeReference Interpreter::InterpretNode_ENT_CONTAINS_VALUE(EvaluableNo auto container = InterpretNodeForImmediateUse(ocn[0]); if(container == nullptr) - return EvaluableNodeReference(evaluableNodeManager->AllocNode(ENT_FALSE), true); + return AllocReturn(false, immediate_result); auto node_stack = CreateInterpreterNodeStackStateSaver(container); From 2d04853966dcb4966ff27ef2301d0a5b979476b5 Mon Sep 17 00:00:00 2001 From: "Christopher J. Hazard, PhD" <143410553+howsohazard@users.noreply.github.com> Date: Fri, 29 Dec 2023 11:02:44 -0500 Subject: [PATCH 55/55] 18652: Updates comment --- src/Amalgam/evaluablenode/EvaluableNodeManagement.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h index f6c8977c..118d8f56 100644 --- a/src/Amalgam/evaluablenode/EvaluableNodeManagement.h +++ b/src/Amalgam/evaluablenode/EvaluableNodeManagement.h @@ -9,7 +9,7 @@ typedef int32_t ExecutionCycleCountCompactDelta; //describes an EvaluableNode value and whether it is uniquely referenced //this is mostly used for actual EvaluableNode *'s, and so most of the methods are built as such -//however, if it may contain an immediate value, then that must be checked via +//however, if it may contain an immediate value, then that must be checked via IsImmediateValue() class EvaluableNodeReference { public: