add better error management (not finished yet)

add check for endless loop in validator (not finished yet)
Better helpMe

17 files changed, 458 insertions, 86 deletions

diff --git a/HelpMe.md b/HelpMe.md
index efb42b7..b3c1a4d 100644
--- a/HelpMe.md
+++ b/HelpMe.md
@@ -45,13 +45,25 @@ Thanks of several operations and option, you can tune a bit you rolling command.
 
 > kX
 
-The option sorts the resulting die list and select the X best dice.
+The option sorts the resulting die list and select the X higher dice.
 
 ### Keep And Explose
 
 > KX
 
-Dice explose if their value are at the die maximum, the option sorts the resulting die list, the it selects the X best dice.
+Dice explose if their value are at the die maximum, the option sorts the resulting die list, the it selects the X higher dice.
+
+### Keep Lower dice
+
+> klX
+
+The option sorts the resulting die list and select the X lowest dice.
+
+### Keep Lower dice
+
+> klX
+
+Dice explose if their value are at the die maximum, the option sorts the resulting die list, the it selects the X lowest dice.
 
 ### Sorting
 
diff --git a/booleancondition.cpp b/booleancondition.cpp
index 49e055a..af4ad10 100644
--- a/booleancondition.cpp
+++ b/booleancondition.cpp
@@ -79,3 +79,19 @@ QString BooleanCondition::toString()
 {
     return QString("BooleanCondition_op_%1_value_%2").arg(m_operator).arg(m_value);
 }
+quint8 BooleanCondition::getValidRangeSize(quint64 faces) const
+{
+    switch (m_operator)
+    {
+    case Equal:
+        return 1;
+    case GreaterThan:
+        return faces-m_value;
+    case LesserThan:
+        return m_value-1;
+    case GreaterOrEqual:
+        return faces-(m_value-1);
+    case LesserOrEqual:
+        return m_value;
+    }
+}
diff --git a/booleancondition.h b/booleancondition.h
index ea5eefd..02fadf9 100644
--- a/booleancondition.h
+++ b/booleancondition.h
@@ -37,6 +37,8 @@ public:
     void setValue(qint64);
     QString toString();
 
+    virtual quint8 getValidRangeSize(quint64 faces) const;
+
 private:
     LogicOperator m_operator;
     qint64 m_value;
diff --git a/diceparser.cpp b/diceparser.cpp
index ea6dcc9..b056be3 100644
--- a/diceparser.cpp
+++ b/diceparser.cpp
@@ -240,24 +240,24 @@ QString DiceParser::displayResult()
 
     QString str;
     QTextStream stream(&str);
-    Result* myResult=next->getResult();
+    Result* result=next->getResult();
 
-    QString totalValue("you get %1 ;");
+    QString totalValue("you got %1 ;");
     QString dieValue("D%1 : {%2} ");
 
     bool scalarDone=false;
-    while(NULL!=myResult)
+    while(NULL!=result)
     {
         ++resulCount;
-        if((myResult->hasResultOfType(Result::SCALAR))&&(!scalarDone))
+        if((result->hasResultOfType(Result::SCALAR))&&(!scalarDone))
         {
-            stream << totalValue.arg(myResult->getResult(Result::SCALAR).toReal()) << endl; //.arg(m_command)
+            stream << totalValue.arg(result->getResult(Result::SCALAR).toReal()) << endl; //.arg(m_command)
             scalarDone=true;
         }
-        else if(myResult->hasResultOfType(Result::DICE_LIST))
+        else if(result->hasResultOfType(Result::DICE_LIST))
         {
 
-            DiceResult* myDiceResult = dynamic_cast<DiceResult*>(myResult);
+            DiceResult* myDiceResult = dynamic_cast<DiceResult*>(result);
             if(NULL!=myDiceResult)
             {
 
@@ -295,12 +295,12 @@ QString DiceParser::displayResult()
 
             }
         }
-        else if(myResult->hasResultOfType(Result::STRING))
+        else if(result->hasResultOfType(Result::STRING))
         {
-           stream << myResult->getResult(Result::STRING).toString();
+           stream << result->getResult(Result::STRING).toString();
         }
 
-        myResult = myResult->getPrevious();
+        result = result->getPrevious();
     }
 
     QTextStream out(stdout);
@@ -312,8 +312,164 @@ QString DiceParser::displayResult()
 
 //    qDebug() << "result count:" << resulCount;
 }
+qreal DiceParser::getLastIntegerResult()
+{
+    ExecutionNode* next = getLeafNode();
+    Result* result=next->getResult();
+    qreal resultValue;
+    bool scalarDone = false;
+    while((result!=NULL)&&(!scalarDone))
+    {
+        if(result->hasResultOfType(Result::SCALAR))
+        {
+            resultValue = result->getResult(Result::SCALAR).toReal();
+            scalarDone=true;
+        }
+        result=result->getPrevious();
+    }
+    return resultValue;
+}
+QString DiceParser::getStringResult()
+{
+    ExecutionNode* next = getLeafNode();
+    QString str;
+
+    Result* result=next->getResult();
+    bool found = false;
+    while((NULL!=result) && (!found) )
+    {
+        if(result->hasResultOfType(Result::STRING))
+        {
+           str = result->getResult(Result::STRING).toString();
+           found = true;
+        }
+
+        result = result->getPrevious();
+    }
+    return str;
+}
+QString DiceParser::getLastDiceResult()
+{
+    ExecutionNode* next = getLeafNode();
+    QString str;
+    QTextStream stream(&str);
+    Result* result=next->getResult();
+    QString dieValue("D%1 : {%2} ");
+    while(NULL!=result)
+    {
+        if(result->hasResultOfType(Result::DICE_LIST))
+        {
+
+            DiceResult* myDiceResult = dynamic_cast<DiceResult*>(result);
+            if(NULL!=myDiceResult)
+            {
+
+                QString resulStr;
+                quint64 face=0;
+                foreach(Die* die, myDiceResult->getResultList())
+                {
+                    if(!die->hasBeenDisplayed())
+                    {
+                        resulStr+=QString("%1").arg(die->getValue());
+                        die->displayed();
+                        face = die->getFaces();
+
+
+                        if(die->hasChildrenValue())
+                        {
+                            resulStr+=" [";
+                            foreach(qint64 i, die->getListValue())
+                            {
+
+                                resulStr+=QString("%1,").arg(i);
+                            }
+                            resulStr.remove(resulStr.size()-1,1);
+                            resulStr+="]";
+                        }
+                        resulStr+=", ";
+                    }
+                }
+                resulStr.remove(resulStr.size()-2,2);
+
+                if(!resulStr.isEmpty())
+                {
+                    stream << dieValue.arg(face).arg(resulStr);
+                }
+            }
+        }
 
+        result = result->getPrevious();
+    }
+
+    return str.simplified();
+}
+QString DiceParser::getDiceCommand()
+{
+    return m_command;
+}
+
+bool DiceParser::hasIntegerResultNotInFirst()
+{
+    return hasResultOfType(Result::SCALAR,true);
+}
+
+bool DiceParser::hasDiceResult()
+{
+    return hasResultOfType(Result::DICE_LIST);
+}
+bool DiceParser::hasStringResult()
+{
+    return hasResultOfType(Result::STRING);
+}
+bool DiceParser::hasResultOfType(Result::RESULT_TYPE type, bool notthelast)
+{
+    ExecutionNode* next = getLeafNode();
+    Result* result=next->getResult();
+    bool scalarDone = false;
+    while((result!=NULL)&&(!scalarDone))
+    {
+        if(result->hasResultOfType(type) && ((!notthelast)||(notthelast && (NULL!=result->getPrevious()))))
+        {
+            scalarDone=true;
+        }
+        result=result->getPrevious();
+    }
+    return scalarDone;
+}
+qreal DiceParser::getSumOfDiceResult()
+{
+    ExecutionNode* next = getLeafNode();
+    qreal resultValue=0;
+    Result* result=next->getResult();
+    bool found = false;
+    while((NULL!=result)&&(!found))
+    {
+        if(result->hasResultOfType(Result::DICE_LIST))
+        {
+            DiceResult* myDiceResult = dynamic_cast<DiceResult*>(result);
+            if(NULL!=myDiceResult)
+            {
+                foreach(Die* die, myDiceResult->getResultList())
+                {
+                    resultValue+=die->getValue();
+                }
+                found = true;
+            }
+        }
+        result = result->getPrevious();
+    }
+    return resultValue;
+}
 
+ExecutionNode* DiceParser::getLeafNode()
+{
+    ExecutionNode* next = m_start;
+    while(NULL != next->getNextNode() )
+    {
+        next = next->getNextNode();
+    }
+    return next;
+}
 
 bool DiceParser::readDice(QString&  str,ExecutionNode* & node)
 {
@@ -499,11 +655,19 @@ DiceRollerNode* DiceParser::addRollDiceNode(qint64 faces,ExecutionNode* previous
     previous->setNextNode(mydiceRoller);
     return mydiceRoller;
 }
-
+ExploseDiceNode* DiceParser::addExploseDiceNode(qint64 value,ExecutionNode* previous)
+{
+    ExploseDiceNode* exploseDiceNode= new ExploseDiceNode();
+    BooleanCondition* condition = new BooleanCondition();
+    condition->setValue(value);
+    condition->setOperator(BooleanCondition::Equal);
+    m_parsingToolbox->isValidValidator(previous,condition);
+    exploseDiceNode->setValidator(condition);
+    previous->setNextNode(exploseDiceNode);
+    return exploseDiceNode;
+}
 bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
 {
-
-
     if(str.isEmpty())
     {
         return false;
@@ -512,8 +676,6 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
     ExecutionNode* node = NULL;
     bool isFine=false;
 
-
-
     for(int i = 0; ((i<m_OptionOp->keys().size())&&(!isFine));++i )
     {
         QString tmp =m_OptionOp->keys().at(i);
@@ -528,15 +690,14 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
             case Keep:
             {
                 int myNumber=0;
+                bool ascending = m_parsingToolbox->readAscending(str);
                 if(m_parsingToolbox->readNumber(str,myNumber))
                 {
                     if(!hasDice)
                     {
                         previous = addRollDiceNode(10,previous);
                     }
-
-
-                    node = m_parsingToolbox->addSort(previous,false);
+                    node = m_parsingToolbox->addSort(previous,ascending);
 
                     KeepDiceExecNode* nodeK = new KeepDiceExecNode();
                     nodeK->setDiceKeepNumber(myNumber);
@@ -551,15 +712,18 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
             case KeepAndExplose:
             {
                 int myNumber=0;
+                bool ascending = m_parsingToolbox->readAscending(str);
                 if(m_parsingToolbox->readNumber(str,myNumber))
                 {
                     if(!hasDice)
                     {
                         previous = addRollDiceNode(10,previous);
                     }
+                    DiceRollerNode* nodeTmp = dynamic_cast<DiceRollerNode*>(previous);
 
+                    previous = addExploseDiceNode(nodeTmp->getFaces(),previous);
 
-                    node = m_parsingToolbox->addSort(previous,false);
+                    node = m_parsingToolbox->addSort(previous,ascending);
 
                     KeepDiceExecNode* nodeK = new KeepDiceExecNode();
                     nodeK->setDiceKeepNumber(myNumber);
@@ -571,10 +735,10 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
                 }
             }
                 break;
-                break;
             case Sort:
             {
-                node = m_parsingToolbox->addSort(previous,false);
+                bool ascending = m_parsingToolbox->readAscending(str);
+                node = m_parsingToolbox->addSort(previous,ascending);
 
                 isFine = true;
             }
@@ -584,6 +748,9 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
                 Validator* validator = m_parsingToolbox->readValidator(str);
                 if(NULL!=validator)
                 {
+                    /// @todo display warning here.
+                    bool b = m_parsingToolbox->isValidValidator(previous,validator);
+
                     CountExecuteNode* countNode = new CountExecuteNode();
                     countNode->setValidator(validator);
 
@@ -599,6 +766,8 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
                 Validator* validator = m_parsingToolbox->readValidator(str);
                 if(NULL!=validator)
                 {
+                    /// @todo display warning here.
+                    bool b = m_parsingToolbox->isValidValidator(previous,validator);
                     RerollDiceNode* rerollNode = new RerollDiceNode();
                     if(m_OptionOp->value(tmp)==RerollAndAdd)
                     {
@@ -619,11 +788,16 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
                 Validator* validator = m_parsingToolbox->readValidator(str);
                 if(NULL!=validator)
                 {
+                    if(m_parsingToolbox->isValidValidator(previous,validator))
+                    {
+                        m_errorMap.insert(ExecutionNode::ENDLESS_LOOP_ERROR,tr("this condition introduce an endless loop: %1. Please, change it").arg(validator->toString()))
+                    }
                     ExploseDiceNode* explosedNode = new ExploseDiceNode();
                     explosedNode->setValidator(validator);
                     previous->setNextNode(explosedNode);
                     node = explosedNode;
                     isFine = true;
+
                 }
             }
 
@@ -638,6 +812,17 @@ QList<ExecutionNode::ERROR_CODE>  DiceParser::getErrorList()
 {
 	return m_start->getErrorList();
 }
+QString DiceParser::humanReadableError()
+{
+    QMapIterator<ExecutionNode::ERROR_CODE,QString> i(m_errorMap);
+    QString str="";
+    while (i.hasNext())
+    {
+        i.next();
+        str.append(i.value());
+        str.append("\n");
+    }
+}
 
 bool DiceParser::readOperand(QString& str,ExecutionNode* & node)
 {
diff --git a/diceparser.h b/diceparser.h
index 22dead1..21a71a6 100644
--- a/diceparser.h
+++ b/diceparser.h
@@ -33,6 +33,7 @@
 #include "booleancondition.h"
 #include "parsingtoolbox.h"
 
+class ExploseDiceNode;
 /**
  * @mainpage DiceParser
  *
@@ -95,10 +96,30 @@ public:
      * @brief displayResult
      */
     QString displayResult();
-
+    /**
+     * @brief readExpression
+     * @param str
+     * @param node
+     * @return
+     */
     bool readExpression(QString& str,ExecutionNode* & node);
-
+    /**
+     * @brief displayDotTree
+     */
     void displayDotTree();
+
+    qreal getLastIntegerResult();
+    qreal getSumOfDiceResult();
+
+    QString getLastDiceResult();
+
+    bool hasIntegerResultNotInFirst();
+    bool hasDiceResult();
+    QString getDiceCommand();
+    bool hasStringResult();
+    QString getStringResult();
+
+    QString humanReadableError();
 private:
 
     /**
@@ -147,7 +168,7 @@ private:
 	 * @return
 	 */
     DiceRollerNode* addRollDiceNode(qint64 faces,ExecutionNode*);
-
+    ExploseDiceNode* addExploseDiceNode(qint64 faces,ExecutionNode* previous);
 	/**
 	 * @brief readOperand
 	 * @param node
@@ -166,12 +187,25 @@ private:
 	 * @return
 	 */
 	QList<ExecutionNode::ERROR_CODE>  getErrorList();
-
+    /**
+     * @brief readInstructionOperator
+     * @param c
+     * @return
+     */
     bool readInstructionOperator(QChar c);
-
+    /**
+     * @brief readNode
+     * @param str
+     * @param node
+     * @return
+     */
     bool readNode(QString& str,ExecutionNode* & node);
 
 
+    ExecutionNode* getLeafNode();
+    bool hasResultOfType(Result::RESULT_TYPE,bool notthelast = false);
+
+
 private:
     QMap<QString,DiceOperator>* m_mapDiceOp;
     QMap<QString,OptionOperator>* m_OptionOp;
@@ -179,6 +213,8 @@ private:
     QMap<QString,QString>* m_aliasMap;
     QList<QString>* m_commandList;
 
+    QMap<ExecutionNode::ERROR_CODE,QString> m_errorMap;
+
 
     ExecutionNode* m_start;
     ExecutionNode* m_current;
diff --git a/diceparser.pri b/diceparser.pri
index e69de29..bf9847e 100644
--- a/diceparser.pri
+++ b/diceparser.pri
@@ -0,0 +1,65 @@
+
+INCLUDEPATH += $$PWD/result
+INCLUDEPATH += $$PWD/node
+INCLUDEPATH += $$PWD
+
+SOURCES += $$PWD/diceparser.cpp \
+    $$PWD/result/diceresult.cpp \
+    $$PWD/range.cpp \
+    $$PWD/booleancondition.cpp \
+    $$PWD/validator.cpp \
+    $$PWD/die.cpp \
+    $$PWD/result/result.cpp \
+    $$PWD/result/scalarresult.cpp \
+    $$PWD/parsingtoolbox.cpp \
+    $$PWD/result/stringresult.cpp
+
+
+HEADERS += \
+    $$PWD/diceparser.h \
+    $$PWD/result/diceresult.h \
+    $$PWD/range.h \
+    $$PWD/booleancondition.h \
+    $$PWD/validator.h \
+    $$PWD/die.h \
+    $$PWD/result/result.h \
+    $$PWD/result/scalarresult.h \
+    $$PWD/result/parsingtoolbox.h \
+    $$PWD/result/stringresult.h
+
+
+HEADERS += \
+    $$PWD/node/dicerollernode.h \
+    $$PWD/node/executionnode.h \
+    $$PWD/node/rerolldicenode.h \
+    $$PWD/node/startingnode.h \
+    $$PWD/node/scalaroperatornode.h \
+    $$PWD/node/numbernode.h \
+    $$PWD/node/sortresult.h \
+    $$PWD/node/keepdiceexecnode.h \
+    $$PWD/node/countexecutenode.h \
+    $$PWD/node/explosedicenode.h \
+    $$PWD/node/parenthesesnode.h \
+    $$PWD/node/helpnode.h \
+    $$PWD/node/jumpbackwardnode.h \
+    $$PWD/node/listsetrollnode.h
+
+SOURCES += \
+    $$PWD/node/dicerollernode.cpp \
+    $$PWD/node/executionnode.cpp \
+    $$PWD/node/startingnode.cpp \
+    $$PWD/node/rerolldicenode.cpp \
+    $$PWD/node/scalaroperatornode.cpp \
+    $$PWD/node/numbernode.cpp \
+    $$PWD/node/sortresult.cpp \
+    $$PWD/node/keepdiceexecnode.cpp \
+    $$PWD/node/countexecutenode.cpp \
+    $$PWD/node/explosedicenode.cpp \
+    $$PWD/node/parenthesesnode.cpp \
+    $$PWD/node/helpnode.cpp \
+    $$PWD/node/jumpbackwardnode.cpp \
+    $$PWD/node/listsetrollnode.cpp
+
+
+OTHER_FILES += \
+    $$PWD/HelpMe.md
diff --git a/node/dicerollernode.cpp b/node/dicerollernode.cpp
index 8eecf0d..1fd1a2f 100644
--- a/node/dicerollernode.cpp
+++ b/node/dicerollernode.cpp
@@ -8,24 +8,24 @@
 #include <QTime>
 
 
-DiceRoller::DiceRoller(QMutex* mutex,DiceResult* diceResult,int faces,int count)
-    : m_mutex(mutex),m_sharedDiceResult(diceResult),m_faces(faces),m_diceCount(count)
-{
+//DiceRoller::DiceRoller(QMutex* mutex,DiceResult* diceResult,int faces,int count)
+//    : m_mutex(mutex),m_sharedDiceResult(diceResult),m_faces(faces),m_diceCount(count)
+//{
 
-}
+//}
 
-void DiceRoller::run()
-{
-    for(quint64 i=0; i < m_diceCount ; ++i)
-    {
-        Die* die = new Die();
-        die->setFaces(m_faces);
-        die->roll();
-        m_mutex->lock();
-        m_sharedDiceResult->insertResult(die);
-        m_mutex->unlock();
-    }
-}
+//void DiceRoller::run()
+//{
+//    for(quint64 i=0; i < m_diceCount ; ++i)
+//    {
+//        Die* die = new Die();
+//        die->setFaces(m_faces);
+//        die->roll();
+//        m_mutex->lock();
+//        m_sharedDiceResult->insertResult(die);
+//        m_mutex->unlock();
+//    }
+//}
 
 
 
diff --git a/node/dicerollernode.h b/node/dicerollernode.h
index 472a5d8..d50fe95 100644
--- a/node/dicerollernode.h
+++ b/node/dicerollernode.h
@@ -7,17 +7,17 @@
 
 #include "executionnode.h"
 #include "result/diceresult.h"
-class DiceRoller : public QRunnable
-{
-public:
-    DiceRoller(QMutex* mutex,DiceResult* diceResult,int faces,int count);
-    virtual void run ();
-private:
-    QMutex* m_mutex;
-    DiceResult* m_sharedDiceResult;
-    int m_faces;
-    quint64 m_diceCount;
-};
+//class DiceRoller : public QRunnable
+//{
+//public:
+//    DiceRoller(QMutex* mutex,DiceResult* diceResult,int faces,int count);
+//    virtual void run ();
+//private:
+//    QMutex* m_mutex;
+//    DiceResult* m_sharedDiceResult;
+//    int m_faces;
+//    quint64 m_diceCount;
+//};
 
 /**
  * @brief The DiceRollerNode class
diff --git a/node/executionnode.h b/node/executionnode.h
index e0fc563..cf1514f 100644
--- a/node/executionnode.h
+++ b/node/executionnode.h
@@ -9,7 +9,7 @@
 class ExecutionNode
 {
 public:
-    enum ERROR_CODE {NO_ERROR,DIE_RESULT_EXPECTED,BAD_SYNTAXE};
+    enum ERROR_CODE {NO_ERROR,DIE_RESULT_EXPECTED,BAD_SYNTAXE,ENDLESS_LOOP_ERROR};
     /**
      * @brief ExecutionNode
      */
diff --git a/node/helpnode.cpp b/node/helpnode.cpp
index bae4b21..6135f6c 100644
--- a/node/helpnode.cpp
+++ b/node/helpnode.cpp
@@ -31,7 +31,7 @@ void HelpNode::run(ExecutionNode* previous)
 }
 QString HelpNode::toString()const
 {
-    return QObject::tr("Rolisteam Dice Parser: Full documentation at: https://github.com/obiwankennedy/DiceParser/blob/master/HelpMe.md\n");
+    return QObject::tr("Rolisteam Dice Parser: Full documentation at: <a href=\"https://github.com/obiwankennedy/DiceParser/blob/master/HelpMe.md\">https://github.com/obiwankennedy/DiceParser/blob/master/HelpMe.md</a> \n");
 }
 
 qint64 HelpNode::getPriority() const
diff --git a/node/node.pri b/node/node.pri
index 7ed357c..79c1623 100644
--- a/node/node.pri
+++ b/node/node.pri
@@ -1,31 +1,31 @@
 HEADERS += \
-    node/dicerollernode.h \
-    node/executionnode.h \
-    node/rerolldicenode.h \
-    node/startingnode.h \
-    node/scalaroperatornode.h \
-    node/numbernode.h \
-    node/sortresult.h \
-    node/keepdiceexecnode.h \
-    node/countexecutenode.h \
-    node/explosedicenode.h \
-    node/parenthesesnode.h \
-    node/helpnode.h \
+    $$PWD/dicerollernode.h \
+    $$PWD/executionnode.h \
+    $$PWD/rerolldicenode.h \
+    $$PWD/startingnode.h \
+    $$PWD/scalaroperatornode.h \
+    $$PWD/numbernode.h \
+    $$PWD/sortresult.h \
+    $$PWD/keepdiceexecnode.h \
+    $$PWD/countexecutenode.h \
+    $$PWD/explosedicenode.h \
+    $$PWD/parenthesesnode.h \
+    $$PWD/helpnode.h \
     $$PWD/jumpbackwardnode.h \
-    node/listsetrollnode.h
+    $$PWD/listsetrollnode.h
 
 SOURCES += \
-    node/dicerollernode.cpp \
-    node/executionnode.cpp \
-    node/startingnode.cpp \
-    node/rerolldicenode.cpp \
-    node/scalaroperatornode.cpp \
-    node/numbernode.cpp \
-    node/sortresult.cpp \
-    node/keepdiceexecnode.cpp \
-    node/countexecutenode.cpp \
-    node/explosedicenode.cpp \
-    node/parenthesesnode.cpp \
-    node/helpnode.cpp \
+    $$PWD/dicerollernode.cpp \
+    $$PWD/executionnode.cpp \
+    $$PWD/startingnode.cpp \
+    $$PWD/rerolldicenode.cpp \
+    $$PWD/scalaroperatornode.cpp \
+    $$PWD/numbernode.cpp \
+    $$PWD/sortresult.cpp \
+    $$PWD/keepdiceexecnode.cpp \
+    $$PWD/countexecutenode.cpp \
+    $$PWD/explosedicenode.cpp \
+    $$PWD/parenthesesnode.cpp \
+    $$PWD/helpnode.cpp \
     $$PWD/jumpbackwardnode.cpp \
-    node/listsetrollnode.cpp
+    $$PWD/listsetrollnode.cpp
diff --git a/node/sortresult.cpp b/node/sortresult.cpp
index 5d7f142..46e6eb8 100644
--- a/node/sortresult.cpp
+++ b/node/sortresult.cpp
@@ -72,9 +72,6 @@ void SortResultNode::run(ExecutionNode* node)
             }
 
         }
-
-
-
         m_diceResult->setResultList(diceList2);
         if(NULL!=m_nextNode)
         {
diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp
index 0d749cc..f276abf 100644
--- a/parsingtoolbox.cpp
+++ b/parsingtoolbox.cpp
@@ -186,3 +186,35 @@ bool ParsingToolBox::readList(QString& str,QStringList& list)
     }
     return false;
 }
+bool ParsingToolBox::readAscending(QString& str)
+{
+    if(str.isEmpty())
+    {
+        return false;
+    }
+    else if(str.at(0)=='l')
+    {
+        str=str.remove(0,1);
+        return true;
+    }
+    return false;
+
+
+}
+bool ParsingToolBox::isValidValidator(ExecutionNode* previous, Validator* val)
+{
+    DiceRollerNode* node = getDiceRollerNode(previous);
+    return (val->getValidRangeSize(node->getFaces())<node->getFaces());
+}
+DiceRollerNode* ParsingToolBox::getDiceRollerNode(ExecutionNode* previous)
+{
+    while(NULL!=previous)
+    {
+        DiceRollerNode* node = dynamic_cast<DiceRollerNode*>(previous);
+        if(NULL!=node)
+        {
+            return node;
+        }
+        previous = previous->getPreviousNode();
+    }
+}
diff --git a/parsingtoolbox.h b/parsingtoolbox.h
index 4c5ce8d..43dca4e 100644
--- a/parsingtoolbox.h
+++ b/parsingtoolbox.h
@@ -25,6 +25,7 @@
 #include <QMap>
 
 #include "node/executionnode.h"
+#include "node/dicerollernode.h"
 #include "booleancondition.h"
 #include "range.h"
 
@@ -42,6 +43,12 @@ public:
 	 * @return
 	 */
     ExecutionNode* addSort(ExecutionNode* e,bool b);
+    /**
+     * @brief readAscending
+     * @param str
+     * @return
+     */
+    bool readAscending(QString& str);
 	/**
 	 * @brief readLogicOperator
 	 * @param str
@@ -86,6 +93,19 @@ public:
      * @return
      */
     bool readList(QString& str,QStringList& list);
+    /**
+     * @brief isValidValidator
+     * @param previous
+     * @param val
+     * @return
+     */
+    bool isValidValidator(ExecutionNode* previous, Validator* val);
+    /**
+     * @brief getDiceRollerNode
+     * @param previous
+     * @return
+     */
+    DiceRollerNode* getDiceRollerNode(ExecutionNode* previous);
 
 private:
         QMap<QString,BooleanCondition::LogicOperator>* m_logicOp;
diff --git a/range.cpp b/range.cpp
index 31667e2..712590f 100644
--- a/range.cpp
+++ b/range.cpp
@@ -56,3 +56,8 @@ QString Range::toString()
 {
     return QString("Range_%1_%2").arg(m_start).arg(m_end);
 }
+quint8 Range::getValidRangeSize(quint64 faces) const
+{
+    Q_UNUSED(faces);
+    return m_end-m_start;
+}
diff --git a/range.h b/range.h
index 4f9cbed..629d0c3 100644
--- a/range.h
+++ b/range.h
@@ -34,6 +34,7 @@ public:
     virtual qint64 hasValid(Die* b,bool recursive) const;
 
     virtual QString toString();
+    virtual quint8 getValidRangeSize(quint64 faces) const;
 
 private:
     qint64 m_start;
diff --git a/validator.h b/validator.h
index 78f3e9c..c9bb78e 100644
--- a/validator.h
+++ b/validator.h
@@ -33,6 +33,7 @@ public:
     virtual qint64 hasValid(Die* b,bool recursive) const = 0 ;
 
     virtual QString toString()=0;
+    virtual quint8 getValidRangeSize(quint64 faces) const = 0 ;
 };
 
 #endif // VALIDATOR_H