Make sure k operator can read value from variable.

4 files changed, 24 insertions, 44 deletions

diff --git a/node/keepdiceexecnode.cpp b/node/keepdiceexecnode.cpp
index 3966c3f..8748a3b 100644
--- a/node/keepdiceexecnode.cpp
+++ b/node/keepdiceexecnode.cpp
@@ -23,7 +23,8 @@
 #include "keepdiceexecnode.h"
 #include "parsingtoolbox.h"
 
-KeepDiceExecNode::KeepDiceExecNode() : m_diceResult(new DiceResult())
+KeepDiceExecNode::KeepDiceExecNode()
+ : m_diceResult(new DiceResult())
 {
     m_result= m_diceResult;
 }
@@ -36,16 +37,16 @@ void KeepDiceExecNode::run(ExecutionNode* previous)
         return;
     }
     m_numberOfDiceNode->run(previous);
-    auto lastnode = ParsingToolBox::getLatestNode(m_numberOfDiceNode);
+    auto lastnode = ParsingToolBox::getLeafNode(m_numberOfDiceNode);
     if(nullptr == lastnode)
         return;
     auto result = lastnode->getResult();
     if(nullptr == result)
         return;
-    if(!result->hasResultOfType(Result::SCALAR))
+    if(!result->hasResultOfType(Dice::RESULT_TYPE::SCALAR))
         return;
 
-    auto numberOfDice = result->getResult(Result::SCALAR).toInt();
+    auto numberOfDice = result->getResult(Dice::RESULT_TYPE::SCALAR).toInt();
 
     DiceResult* previousDiceResult = dynamic_cast<DiceResult*>(previous->getResult());
     m_result->setPrevious(previousDiceResult);
@@ -61,15 +62,15 @@ void KeepDiceExecNode::run(ExecutionNode* previous)
         QList<Die*> diceList3= diceList.mid(0, static_cast<int>(numberOfDice));
         QList<Die*> diceList2;
 
-        for(Die* die : diceList3)
+        for(Die* die : qAsConst(diceList3))
         {
             Die* tmpdie= new Die(*die);
-            //*tmpdie= *die;
             diceList2.append(tmpdie);
             die->displayed();
+            die->setSelected(false);
         }
 
-        if(numberOfDice > static_cast<quint64>(diceList.size()))
+        if(numberOfDice > static_cast<qint64>(diceList.size()))
         {
             m_errors.insert(Dice::ERROR_CODE::TOO_MANY_DICE,
                             QObject::tr(" You ask to keep %1 dice but the result only has %2")
@@ -99,7 +100,7 @@ QString KeepDiceExecNode::toString(bool wl) const
 	if(wl)
 	{
         auto param = m_numberOfDiceNode->toString(wl);
-        return QString("%1 [label=\"KeepDiceExecNode %2\"]").arg(m_id).arg(param);
+        return QString("%1 [label=\"KeepDiceExecNode %2\"]").arg(m_id, param);
 	}
 	else
 	{
diff --git a/node/keepdiceexecnode.h b/node/keepdiceexecnode.h
index c4aa5c5..0dd6616 100644
--- a/node/keepdiceexecnode.h
+++ b/node/keepdiceexecnode.h
@@ -34,15 +34,13 @@ public:
     virtual ~KeepDiceExecNode();
 
     virtual void run(ExecutionNode* previous);
-    //virtual void setDiceKeepNumber(qint64);
     virtual void setDiceKeepNumber(ExecutionNode* valueNode );
     virtual QString toString(bool) const;
     virtual qint64 getPriority() const;
     virtual ExecutionNode* getCopy() const;
 
 private:
-    qint64 m_numberOfDice= 0;
-    ExecutionNode* m_numberOfDiceNode;
+    ExecutionNode* m_numberOfDiceNode = nullptr;
     DiceResult* m_diceResult;
 };
 
diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp
index d371e9b..11f2cba 100644
--- a/parsingtoolbox.cpp
+++ b/parsingtoolbox.cpp
@@ -1559,7 +1559,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
         return false;
     }
 
-    ExecutionNode* node= nullptr;
     bool found= false;
     auto keys= m_OptionOp.keys();
     for(int i= 0; ((i < keys.size()) && (!found)); ++i)
@@ -1574,40 +1573,35 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
             {
             case Keep:
             {
-                qint64 myNumber= 0;
+                ExecutionNode* value=nullptr;
                 bool ascending= readAscending(str);
 
-                if(readNumber(str, myNumber))
+                 if(readOperand(str,value))
                 {
-                    node= addSort(previous, ascending);
+                    auto node= addSort(previous, ascending);
                     KeepDiceExecNode* nodeK= new KeepDiceExecNode();
-                    nodeK->setDiceKeepNumber(myNumber);
+                    nodeK->setDiceKeepNumber(value);
                     node->setNextNode(nodeK);
-                    node= nodeK;
                     found= true;
                 }
             }
             break;
             case KeepAndExplode:
             {
-                qint64 myNumber= 0;
                 bool ascending= readAscending(str);
-                if(readNumber(str, myNumber))
+                ExecutionNode* value=nullptr;
+                if(readOperand(str,value))
                 {
-                    /* if(!hasDice)
-                        {
-                            previous = addRollDiceNode(DEFAULT_FACES_NUMBER,previous);
-                        }*/
                     DiceRollerNode* nodeTmp= dynamic_cast<DiceRollerNode*>(previous);
                     if(nullptr != nodeTmp)
                     {
                         previous= addExplodeDiceNode(static_cast<qint64>(nodeTmp->getFaces()), previous);
                     }
 
-                    node= addSort(previous, ascending);
+                    auto node= addSort(previous, ascending);
 
                     KeepDiceExecNode* nodeK= new KeepDiceExecNode();
-                    nodeK->setDiceKeepNumber(myNumber);
+                    nodeK->setDiceKeepNumber(value);
 
                     node->setNextNode(nodeK);
                     node= nodeK;
@@ -1626,7 +1620,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                     filterNode->setValidatorList(validatorList);
 
                     previous->setNextNode(filterNode);
-                    node= filterNode;
                     found= true;
                 }
             }
@@ -1634,7 +1627,7 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
             case Sort:
             {
                 bool ascending= readAscending(str);
-                node= addSort(previous, ascending);
+                addSort(previous, ascending);
                 /*if(!hasDice)
                     {
                         m_errorMap.insert(ExecutionNode::BAD_SYNTAXE,QObject::tr("Sort Operator does not support default
@@ -1654,7 +1647,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                     countNode->setValidatorList(validatorList);
 
                     previous->setNextNode(countNode);
-                    node= countNode;
                     found= true;
                 }
                 else
@@ -1709,7 +1701,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                         }
                         rerollNode->setValidatorList(validatorList);
                         previous->setNextNode(rerollNode);
-                        node= rerollNode;
                         found= true;
                     }
                     else
@@ -1734,7 +1725,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                     ExplodeDiceNode* explodedNode= new ExplodeDiceNode();
                     explodedNode->setValidatorList(validatorList);
                     previous->setNextNode(explodedNode);
-                    node= explodedNode;
                     found= true;
                 }
                 else
@@ -1749,7 +1739,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                 MergeNode* mergeNode= new MergeNode();
                 mergeNode->setStartList(&m_startNodes);
                 previous->setNextNode(mergeNode);
-                node= mergeNode;
                 found= true;
             }
             break;
@@ -1757,7 +1746,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
             {
                 AllSameNode* allSame= new AllSameNode();
                 previous->setNextNode(allSame);
-                node= allSame;
                 found= true;
             }
             break;
@@ -1766,8 +1754,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                 auto scNode= new SwitchCaseNode();
                 found= readSwitchCaseNode(str, scNode);
                 previous->setNextNode(scNode);
-                if(found)
-                    node= scNode;
             }
             break;
             case TransformOption:
@@ -1775,8 +1761,7 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                 auto scNode= new ReplaceValueNode();
                 found= readReplaceValueNode(str, scNode);
                 previous->setNextNode(scNode);
-                if(found)
-                    node= scNode;
+
             }
             break;
             case Bind:
@@ -1784,7 +1769,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                 BindNode* bindNode= new BindNode();
                 bindNode->setStartList(&m_startNodes);
                 previous->setNextNode(bindNode);
-                node= bindNode;
                 found= true;
             }
             break;
@@ -1809,13 +1793,12 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                     }
                 }
                 previous->setNextNode(occNode);
-                node= occNode;
                 found= true;
             }
             break;
             case Unique:
             {
-                node= new UniqueNode();
+                auto node= new UniqueNode();
                 previous->setNextNode(node);
                 found= true;
             }
@@ -1832,7 +1815,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                 else
                 {
                     previous->setNextNode(painter);
-                    node= painter;
                     found= true;
                 }
             }
@@ -1852,7 +1834,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                         nodeif->setInstructionFalse(falseNode);
                         nodeif->setValidatorList(validatorList);
                         previous->setNextNode(nodeif);
-                        node= nodeif;
                         found= true;
                     }
                     else
@@ -1870,7 +1851,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
             {
                 SplitNode* splitnode= new SplitNode();
                 previous->setNextNode(splitnode);
-                node= splitnode;
                 found= true;
             }
             break;
@@ -1883,7 +1863,6 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                     GroupNode* groupNode= new GroupNode(stringResult);
                     groupNode->setGroupValue(groupNumber);
                     previous->setNextNode(groupNode);
-                    node= groupNode;
                     found= true;
                 }
             }
diff --git a/tests/dice/tst_dice.cpp b/tests/dice/tst_dice.cpp
index 97feb95..999f85b 100644
--- a/tests/dice/tst_dice.cpp
+++ b/tests/dice/tst_dice.cpp
@@ -614,7 +614,9 @@ void TestDice::keepTest()
 
     TestNode node;
     KeepDiceExecNode keepN;
-    keepN.setDiceKeepNumber(keep);
+    NumberNode* numberNode = new NumberNode();
+    numberNode->setNumber(keep);
+    keepN.setDiceKeepNumber(numberNode);
 
     DiceResult result;