Merge branch 'liberation' into 'master'

Add fuzzer on the DiceParser

See merge request kde/rolisteam-diceparser!2

19 files changed, 127 insertions, 106 deletions

diff --git a/node/countexecutenode.cpp b/node/countexecutenode.cpp
index bc8e3b3..763a320 100644
--- a/node/countexecutenode.cpp
+++ b/node/countexecutenode.cpp
@@ -34,7 +34,7 @@ void CountExecuteNode::run(ExecutionNode* previous)
         {
             if(nullptr != m_validator)
             {
-                sum+= m_validator->hasValid(dice, true, true);
+                sum+= m_validator->hasValid(dice, true, true) ? 1 : 0;
             }
         }
         m_scalarResult->setValue(sum);
diff --git a/node/dicerollernode.cpp b/node/dicerollernode.cpp
index f57d3e3..f87908f 100644
--- a/node/dicerollernode.cpp
+++ b/node/dicerollernode.cpp
@@ -19,10 +19,10 @@ void DiceRollerNode::run(ExecutionNode* previous)
         Result* result= previous->getResult();
         if(nullptr != result)
         {
-            auto num= result->getResult(Result::SCALAR).toReal();
+            auto num= result->getResult(Dice::RESULT_TYPE::SCALAR).toReal();
             if(num <= 0)
             {
-                m_errors.insert(NO_DICE_TO_ROLL, QObject::tr("No dice to roll"));
+                m_errors.insert(Dice::ERROR_CODE::NO_DICE_TO_ROLL, QObject::tr("No dice to roll"));
             }
             m_diceCount= num > 0 ? static_cast<quint64>(num) : 0;
             m_result->setPrevious(result);
@@ -30,7 +30,7 @@ void DiceRollerNode::run(ExecutionNode* previous)
             auto possibleValue= static_cast<quint64>(std::abs((m_max - m_min) + 1));
             if(possibleValue < m_diceCount && m_unique)
             {
-                m_errors.insert(TOO_MANY_DICE,
+                m_errors.insert(Dice::ERROR_CODE::TOO_MANY_DICE,
                                 QObject::tr("More unique values asked than possible values (D operator)"));
                 return;
             }
@@ -62,7 +62,7 @@ void DiceRollerNode::run(ExecutionNode* previous)
 
 quint64 DiceRollerNode::getFaces() const
 {
-    return std::abs(m_max - m_min) + 1;
+    return static_cast<quint64>(std::abs(m_max - m_min) + 1);
 }
 
 std::pair<qint64, qint64> DiceRollerNode::getRange() const
diff --git a/node/executionnode.cpp b/node/executionnode.cpp
index 5bee091..4545934 100644
--- a/node/executionnode.cpp
+++ b/node/executionnode.cpp
@@ -6,7 +6,7 @@ ExecutionNode::ExecutionNode()
     : m_previousNode(nullptr)
     , m_result(nullptr)
     , m_nextNode(nullptr)
-    , m_errors(QMap<ExecutionNode::DICE_ERROR_CODE, QString>())
+    , m_errors(QMap<Dice::ERROR_CODE, QString>())
     , m_id(QString("\"%1\"").arg(QUuid::createUuid().toString()))
 {
 }
@@ -40,7 +40,7 @@ ExecutionNode* ExecutionNode::getNextNode()
 {
     return m_nextNode;
 }
-QMap<ExecutionNode::DICE_ERROR_CODE, QString> ExecutionNode::getExecutionErrorMap()
+QMap<Dice::ERROR_CODE, QString> ExecutionNode::getExecutionErrorMap()
 {
     if(nullptr != m_nextNode)
     {
@@ -97,5 +97,5 @@ qint64 ExecutionNode::getScalarResult()
 {
     if(m_result == nullptr)
         return 0;
-    return m_result->getResult(Result::SCALAR).toInt();
+    return m_result->getResult(Dice::RESULT_TYPE::SCALAR).toInt();
 }
diff --git a/node/executionnode.h b/node/executionnode.h
index e8eca1f..6321c83 100644
--- a/node/executionnode.h
+++ b/node/executionnode.h
@@ -1,8 +1,8 @@
 #ifndef EXECUTIONNODE_H
 #define EXECUTIONNODE_H
 
+#include "diceparserhelper.h"
 #include "result/result.h"
-#include <QDebug>
 
 /**
  * @brief The ExecutionNode class
@@ -10,21 +10,6 @@
 class ExecutionNode
 {
 public:
-    enum DICE_ERROR_CODE
-    {
-        NO_DICE_ERROR,
-        DIE_RESULT_EXPECTED,
-        BAD_SYNTAXE,
-        ENDLESS_LOOP_ERROR,
-        DIVIDE_BY_ZERO,
-        NOTHING_UNDERSTOOD,
-        NO_DICE_TO_ROLL,
-        TOO_MANY_DICE,
-        NO_VARIBALE,
-        INVALID_INDEX,
-        UNEXPECTED_CHARACTER,
-        NO_PREVIOUS_ERROR
-    };
     /**
      * @brief ExecutionNode
      */
@@ -72,7 +57,7 @@ public:
      * @brief getErrorList
      * @return
      */
-    virtual QMap<ExecutionNode::DICE_ERROR_CODE, QString> getExecutionErrorMap();
+    virtual QMap<Dice::ERROR_CODE, QString> getExecutionErrorMap();
 
     /**
      * @brief generateDotTree
@@ -101,7 +86,7 @@ protected:
     /**
      * @brief m_result
      */
-    Result* m_result;
+    Result* m_result= nullptr;
     /**
      * @brief m_nextNode
      */
@@ -109,7 +94,7 @@ protected:
     /**
      * @brief m_errors
      */
-    QMap<ExecutionNode::DICE_ERROR_CODE, QString> m_errors;
+    QMap<Dice::ERROR_CODE, QString> m_errors;
 
     QString m_id;
 };
diff --git a/node/explodedicenode.cpp b/node/explodedicenode.cpp
index 704ac8a..2292a05 100644
--- a/node/explodedicenode.cpp
+++ b/node/explodedicenode.cpp
@@ -16,7 +16,6 @@ void ExplodeDiceNode::run(ExecutionNode* previous)
             for(auto& die : previous_result->getResultList())
             {
                 Die* tmpdie= new Die(*die);
-//                *tmpdie= *die;
                 m_diceResult->insertResult(tmpdie);
                 die->displayed();
             }
@@ -25,12 +24,23 @@ void ExplodeDiceNode::run(ExecutionNode* previous)
 
             for(auto& die : list)
             {
+                if(Dice::CONDITION_STATE::ALWAYSTRUE
+                   == m_validator->isValidRangeSize(std::make_pair<qint64, qint64>(die->getBase(), die->getMaxValue())))
+                {
+                    m_errors.insert(Dice::ERROR_CODE::ENDLESS_LOOP_ERROR,
+                                    QObject::tr("Condition (%1) cause an endless loop with this dice: %2")
+                                        .arg(toString(true))
+                                        .arg(QStringLiteral("d[%1,%2]")
+                                                 .arg(static_cast<int>(die->getBase()))
+                                                 .arg(static_cast<int>(die->getMaxValue()))));
+                    continue;
+                }
+
                 while(m_validator->hasValid(die, false))
                 {
                     die->roll(true);
                 }
             }
-            // m_diceResult->setResultList(list);
 
             if(nullptr != m_nextNode)
             {
diff --git a/node/forloopnode.cpp b/node/forloopnode.cpp
index f65a389..aba6ff4 100644
--- a/node/forloopnode.cpp
+++ b/node/forloopnode.cpp
@@ -58,7 +58,7 @@ void ForLoopNode::run(ExecutionNode* previous)
                     tmp= tmp->getNextNode();
                 }
                 Result* internalResult= tmp->getResult();
-                auto value= internalResult->getResult(Result::SCALAR).toInt();
+                auto value= internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toInt();
 
                 Die* neodie= new Die();
                 *neodie= *dice;
diff --git a/node/ifnode.cpp b/node/ifnode.cpp
index 5470e15..f0f28aa 100644
--- a/node/ifnode.cpp
+++ b/node/ifnode.cpp
@@ -41,11 +41,11 @@ void IfNode::run(ExecutionNode* previous)
     ExecutionNode* nextNode= nullptr;
     bool runNext= (nullptr == m_nextNode) ? false : true;
     Result* previousResult= previous->getResult();
-    m_result= previousResult;
+    m_result= previousResult->getCopy();
 
     if(nullptr != m_result)
     {
-        qreal value= previousResult->getResult(Result::SCALAR).toReal();
+        qreal value= previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal();
 
         if(nullptr != m_validator)
         {
diff --git a/node/jumpbackwardnode.cpp b/node/jumpbackwardnode.cpp
index 15c7063..2870854 100644
--- a/node/jumpbackwardnode.cpp
+++ b/node/jumpbackwardnode.cpp
@@ -96,7 +96,7 @@ void JumpBackwardNode::run(ExecutionNode* previous)
         if(nullptr != result)
         {
             //--i;
-            if(/*(i==0)&&*/ (result->hasResultOfType(Result::DICE_LIST)))
+            if(/*(i==0)&&*/ (result->hasResultOfType(Dice::RESULT_TYPE::DICE_LIST)))
             {
                 found= true;
                 m_backwardNode= parent;
@@ -118,7 +118,8 @@ void JumpBackwardNode::run(ExecutionNode* previous)
     }
     if(nullptr == result)
     {
-        m_errors.insert(DIE_RESULT_EXPECTED,
+        m_errors.insert(
+            Dice::ERROR_CODE::DIE_RESULT_EXPECTED,
             QObject::tr(" The @ operator expects dice result. Please check the documentation to fix your command."));
     }
     else
diff --git a/node/keepdiceexecnode.cpp b/node/keepdiceexecnode.cpp
index 42b4c40..688c27b 100644
--- a/node/keepdiceexecnode.cpp
+++ b/node/keepdiceexecnode.cpp
@@ -58,9 +58,10 @@ void KeepDiceExecNode::run(ExecutionNode* previous)
 
         if(m_numberOfDice > static_cast<qint64>(diceList.size()))
         {
-            m_errors.insert(TOO_MANY_DICE, QObject::tr(" You ask to keep %1 dice but the result only has %2")
-                                               .arg(m_numberOfDice)
-                                               .arg(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")
+                                .arg(m_numberOfDice)
+                                .arg(diceList.size()));
         }
 
         for(auto& tmp : diceList.mid(static_cast<int>(m_numberOfDice), -1))
diff --git a/node/listsetrollnode.cpp b/node/listsetrollnode.cpp
index ffa0f03..565a609 100644
--- a/node/listsetrollnode.cpp
+++ b/node/listsetrollnode.cpp
@@ -62,11 +62,11 @@ void ListSetRollNode::run(ExecutionNode* previous)
         Result* result= previous->getResult();
         if(nullptr != result)
         {
-            quint64 diceCount= result->getResult(Result::SCALAR).toReal();
+            quint64 diceCount= result->getResult(Dice::RESULT_TYPE::SCALAR).toReal();
             if(diceCount > static_cast<quint64>(m_values.size()) && m_unique)
             {
-                m_errors.insert(
-                    TOO_MANY_DICE, QObject::tr("More unique values asked than possible values (L operator)"));
+                m_errors.insert(Dice::ERROR_CODE::TOO_MANY_DICE,
+                                QObject::tr("More unique values asked than possible values (L operator)"));
             }
             else
             {
diff --git a/node/mergenode.cpp b/node/mergenode.cpp
index 4a11a76..15f2fa7 100644
--- a/node/mergenode.cpp
+++ b/node/mergenode.cpp
@@ -29,7 +29,7 @@ void MergeNode::run(ExecutionNode* previous)
 {
     if(nullptr == previous)
     {
-        m_errors.insert(ExecutionNode::NO_PREVIOUS_ERROR, QObject::tr("No previous node before Merge operator"));
+        m_errors.insert(Dice::ERROR_CODE::NO_PREVIOUS_ERROR, QObject::tr("No previous node before Merge operator"));
         return;
     }
 
@@ -40,46 +40,46 @@ void MergeNode::run(ExecutionNode* previous)
     for(auto start : *m_startList)
     {
         ExecutionNode* last= getLatestNode(start);
-        if(nullptr != last)
+        if(nullptr == last || nullptr == previousLast)
+            continue;
+
+        auto startResult= start->getResult();
+        if(nullptr == startResult)
+            continue;
+
+        startResult->setPrevious(previousLast->getResult());
+        previousLast->setNextNode(start);
+
+        previousLast= last;
+        Result* tmpResult= last->getResult();
+        while(nullptr != tmpResult)
         {
-            if(nullptr != previousLast)
+            DiceResult* dice= dynamic_cast<DiceResult*>(tmpResult);
+            if(nullptr == dice)
             {
-                auto startResult= start->getResult();
-                startResult->setPrevious(previousLast->getResult());
-                previousLast->setNextNode(start);
-            }
-            previousLast= last;
-            Result* tmpResult= last->getResult();
-            while(nullptr != tmpResult)
-            {
-                DiceResult* dice= dynamic_cast<DiceResult*>(tmpResult);
-                if(nullptr != dice)
+                ///@todo TODO improve here to set homogeneous while is really
+                m_diceResult->setHomogeneous(false);
+                for(auto& die : dice->getResultList())
                 {
-                    ///@todo TODO improve here to set homogeneous while is really
-                    m_diceResult->setHomogeneous(false);
-                    for(auto& die : dice->getResultList())
+                    if(!m_diceResult->getResultList().contains(die) && (!die->hasBeenDisplayed()))
                     {
-                        if(!m_diceResult->getResultList().contains(die) && (!die->hasBeenDisplayed()))
-                        {
-                            Die* tmpdie= new Die(*die);
-                            //*tmpdie= *die;
-                            die->displayed();
-                            m_diceResult->getResultList().append(tmpdie);
-                        }
+                        Die* tmpdie= new Die(*die);
+                        die->displayed();
+                        m_diceResult->getResultList().append(tmpdie);
                     }
                 }
-                auto it= std::find_if(pastResult.begin(), pastResult.end(),
-                    [tmpResult](const Result* a) { return (a == tmpResult->getPrevious()); });
-                if(it == pastResult.end())
-                {
-                    pastResult.push_back(previousLast->getResult());
-                    tmpResult= tmpResult->getPrevious();
-                }
-                else
-                {
-                    tmpResult->setPrevious(nullptr);
-                    tmpResult= nullptr;
-                }
+            }
+            auto it= std::find_if(pastResult.begin(), pastResult.end(),
+                                  [tmpResult](const Result* a) { return (a == tmpResult->getPrevious()); });
+            if(it == pastResult.end())
+            {
+                pastResult.push_back(previousLast->getResult());
+                tmpResult= tmpResult->getPrevious();
+            }
+            else
+            {
+                tmpResult->setPrevious(nullptr);
+                tmpResult= nullptr;
             }
         }
     }
diff --git a/node/occurencecountnode.cpp b/node/occurencecountnode.cpp
index e0117ef..0d69d2a 100644
--- a/node/occurencecountnode.cpp
+++ b/node/occurencecountnode.cpp
@@ -20,6 +20,7 @@
 #include "occurencecountnode.h"
 #include "result/diceresult.h"
 #include "result/stringresult.h"
+#include <QVector>
 
 OccurenceCountNode::OccurenceCountNode() : ExecutionNode() {}
 
diff --git a/node/paintnode.cpp b/node/paintnode.cpp
index 02c7230..0cd4e10 100644
--- a/node/paintnode.cpp
+++ b/node/paintnode.cpp
@@ -47,7 +47,6 @@ void ColorItem::setColor(const QString& color)
 
 PainterNode::PainterNode() : ExecutionNode()
 {
-    m_result= nullptr;
     m_nextNode= nullptr;
 }
 
@@ -61,15 +60,17 @@ void PainterNode::run(ExecutionNode* previous)
     m_previousNode= previous;
     if(nullptr == previous)
     {
-        m_errors.insert(ExecutionNode::NO_PREVIOUS_ERROR, QObject::tr("No previous node before Paint operator"));
+        m_errors.insert(Dice::ERROR_CODE::NO_PREVIOUS_ERROR, QObject::tr("No previous node before Paint operator"));
         return;
     }
     Result* previousResult= previous->getResult();
-    // m_result = previousResult;
-    DiceResult* previousDiceResult= dynamic_cast<DiceResult*>(previousResult);
-    if(nullptr != previousDiceResult)
+    if(nullptr == previousResult)
+        return;
+
+    m_diceResult= dynamic_cast<DiceResult*>(previousResult->getCopy());
+    if(nullptr != m_diceResult)
     {
-        QList<Die*> diceList= previousDiceResult->getResultList();
+        QList<Die*> diceList= m_diceResult->getResultList();
         int pastDice= 0;
         for(ColorItem& item : m_colors)
         {
@@ -90,7 +91,7 @@ void PainterNode::run(ExecutionNode* previous)
 }
 Result* PainterNode::getResult()
 {
-    return (nullptr != m_previousNode) ? m_previousNode->getResult() : nullptr;
+    return m_diceResult;
 }
 
 QString PainterNode::toString(bool wl) const
diff --git a/node/paintnode.h b/node/paintnode.h
index 2675285..2283f83 100644
--- a/node/paintnode.h
+++ b/node/paintnode.h
@@ -55,6 +55,7 @@ public:
 
 protected:
     QList<ColorItem> m_colors;
+    DiceResult* m_diceResult= nullptr;
 };
 
 #endif
diff --git a/node/rerolldicenode.cpp b/node/rerolldicenode.cpp
index 56ee6d9..70475a5 100644
--- a/node/rerolldicenode.cpp
+++ b/node/rerolldicenode.cpp
@@ -1,5 +1,6 @@
 #include "rerolldicenode.h"
 #include "parsingtoolbox.h"
+#include <utility>
 
 RerollDiceNode::RerollDiceNode(bool reroll, bool addingMode)
     : m_diceResult(new DiceResult()), m_validator(nullptr), m_reroll(reroll), m_adding(addingMode)
@@ -26,7 +27,6 @@ void RerollDiceNode::run(ExecutionNode* previous)
             for(auto& die : previous_result->getResultList())
             {
                 Die* tmpdie= new Die(*die);
-                //*tmpdie= *die;
                 m_diceResult->insertResult(tmpdie);
                 die->displayed();
             }
@@ -35,10 +35,22 @@ void RerollDiceNode::run(ExecutionNode* previous)
             QList<Die*>& list= m_diceResult->getResultList();
             QList<Die*> toRemove;
 
-            for(int i= 0; i < list.size(); ++i)
+            for(auto& die : list)
             {
-                auto die= list.at(i);
                 bool finished= false;
+                auto state
+                    = m_validator->isValidRangeSize(std::make_pair<qint64, qint64>(die->getBase(), die->getMaxValue()));
+                if((Dice::CONDITION_STATE::ALWAYSTRUE == state && m_adding)
+                   || (!m_reroll && !m_adding && state == Dice::CONDITION_STATE::UNREACHABLE))
+                {
+                    m_errors.insert(Dice::ERROR_CODE::ENDLESS_LOOP_ERROR,
+                                    QObject::tr("Condition (%1) cause an endless loop with this dice: %2")
+                                        .arg(toString(true))
+                                        .arg(QStringLiteral("d[%1,%2]")
+                                                 .arg(static_cast<int>(die->getBase()))
+                                                 .arg(static_cast<int>(die->getMaxValue()))));
+                    continue;
+                }
                 while(m_validator->hasValid(die, false) && !finished)
                 {
                     if(m_instruction != nullptr)
@@ -52,8 +64,8 @@ void RerollDiceNode::run(ExecutionNode* previous)
                             {
                                 toRemove.append(die);
                                 list.append(lastResult->getResultList());
+                                lastResult->clear();
                             }
-                            lastResult->clear();
                         }
                     }
                     else
@@ -79,7 +91,8 @@ void RerollDiceNode::run(ExecutionNode* previous)
         }
         else
         {
-            m_errors.insert(ExecutionNode::DIE_RESULT_EXPECTED,
+            m_errors.insert(
+                Dice::ERROR_CODE::DIE_RESULT_EXPECTED,
                 QObject::tr(
                     " The a operator expects dice result. Please check the documentation and fix your command."));
         }
diff --git a/node/scalaroperatornode.cpp b/node/scalaroperatornode.cpp
index 3a26fc7..821150b 100644
--- a/node/scalaroperatornode.cpp
+++ b/node/scalaroperatornode.cpp
@@ -66,31 +66,39 @@ void ScalarOperatorNode::run(ExecutionNode* previous)
                     m_internalNode->getResult()->setPrevious(previousResult);
                 }
 
+                if(internalResult == nullptr)
+                {
+                    m_errors.insert(Dice::ERROR_CODE::NO_VALID_RESULT,
+                                    QObject::tr("No Valid result in arithmetic operatoion: %1").arg(toString(true)));
+                    return;
+                }
+
                 switch(m_arithmeticOperator)
                 {
                 case Die::PLUS:
-                    m_scalarResult->setValue(add(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal()));
+                    m_scalarResult->setValue(add(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                 internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal()));
                     break;
                 case Die::MINUS:
-                    m_scalarResult->setValue(substract(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal()));
+                    m_scalarResult->setValue(substract(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                       internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal()));
                     break;
                 case Die::MULTIPLICATION:
-                    m_scalarResult->setValue(multiple(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal()));
+                    m_scalarResult->setValue(multiple(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                      internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal()));
                     break;
                 case Die::DIVIDE:
-                    m_scalarResult->setValue(divide(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal()));
+                    m_scalarResult->setValue(divide(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                    internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal()));
                     break;
                 case Die::INTEGER_DIVIDE:
-                    m_scalarResult->setValue(static_cast<int>(divide(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal())));
+                    m_scalarResult->setValue(
+                        static_cast<int>(divide(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal())));
                     break;
                 case Die::POW:
-                    m_scalarResult->setValue(pow(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal()));
+                    m_scalarResult->setValue(pow(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                 internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal()));
                     break;
                 }
             }
@@ -128,7 +136,7 @@ qreal ScalarOperatorNode::divide(qreal a, qreal b)
 {
     if(qFuzzyCompare(b, 0))
     {
-        m_errors.insert(DIVIDE_BY_ZERO, QObject::tr("Division by zero"));
+        m_errors.insert(Dice::ERROR_CODE::DIVIDE_BY_ZERO, QObject::tr("Division by zero"));
         return 0;
     }
     return static_cast<qreal>(a / b);
@@ -240,12 +248,12 @@ void ScalarOperatorNode::generateDotTree(QString& s)
     }
     s.append(str);
 }
-QMap<ExecutionNode::DICE_ERROR_CODE, QString> ScalarOperatorNode::getExecutionErrorMap()
+QMap<Dice::ERROR_CODE, QString> ScalarOperatorNode::getExecutionErrorMap()
 {
     if(nullptr != m_internalNode)
     {
         auto keys= m_internalNode->getExecutionErrorMap().keys();
-        for(ExecutionNode::DICE_ERROR_CODE& key : keys)
+        for(const auto& key : keys)
         {
             m_errors.insert(key, m_internalNode->getExecutionErrorMap().value(key));
         }
@@ -253,7 +261,7 @@ QMap<ExecutionNode::DICE_ERROR_CODE, QString> ScalarOperatorNode::getExecutionEr
     if(nullptr != m_nextNode)
     {
         auto keys= m_nextNode->getExecutionErrorMap().keys();
-        for(ExecutionNode::DICE_ERROR_CODE& key : keys)
+        for(auto const& key : keys)
         {
             m_errors.insert(key, m_nextNode->getExecutionErrorMap().value(key));
         }
diff --git a/node/scalaroperatornode.h b/node/scalaroperatornode.h
index 2ac89b0..a58a8d3 100644
--- a/node/scalaroperatornode.h
+++ b/node/scalaroperatornode.h
@@ -76,7 +76,7 @@ public:
      * @brief getErrorList
      * @return
      */
-    virtual QMap<ExecutionNode::DICE_ERROR_CODE, QString> getExecutionErrorMap();
+    virtual QMap<Dice::ERROR_CODE, QString> getExecutionErrorMap();
     /**
      * @brief getArithmeticOperator
      * @return
diff --git a/node/valueslistnode.cpp b/node/valueslistnode.cpp
index b31ee84..d378350 100644
--- a/node/valueslistnode.cpp
+++ b/node/valueslistnode.cpp
@@ -16,7 +16,7 @@ void ValuesListNode::run(ExecutionNode* previous)
         auto result= node->getResult();
         if(!result)
             continue;
-        auto val= result->getResult(Result::SCALAR).toInt();
+        auto val= result->getResult(Dice::RESULT_TYPE::SCALAR).toInt();
         Die* die= new Die();
         auto dyna= dynamic_cast<VariableNode*>(node);
         if(nullptr != dyna)
diff --git a/node/variablenode.cpp b/node/variablenode.cpp
index 1d13a2c..e45214d 100644
--- a/node/variablenode.cpp
+++ b/node/variablenode.cpp
@@ -24,7 +24,7 @@ void VariableNode::run(ExecutionNode* previous)
     }
     else
     {
-        m_errors.insert(NO_VARIBALE, QObject::tr("No variable at index:%1").arg(m_index + 1));
+        m_errors.insert(Dice::ERROR_CODE::NO_VARIBALE, QObject::tr("No variable at index:%1").arg(m_index + 1));
     }
 }