Merge branch 'master' of github.com:obiwankennedy/DiceParser

30 files changed, 319 insertions, 153 deletions

diff --git a/node/countexecutenode.cpp b/node/countexecutenode.cpp
index ff3d67b..55b278e 100644
--- a/node/countexecutenode.cpp
+++ b/node/countexecutenode.cpp
@@ -6,11 +6,11 @@
 CountExecuteNode::CountExecuteNode()
 	: m_scalarResult(new ScalarResult()),m_validator(NULL)
 {
-    m_result = m_scalarResult;
+	m_result = m_scalarResult;
 }
 void CountExecuteNode::setValidator(Validator* validator)
 {
-    m_validator = validator;
+	m_validator = validator;
 }
 CountExecuteNode::~CountExecuteNode()
 {
@@ -23,41 +23,48 @@ CountExecuteNode::~CountExecuteNode()
 void CountExecuteNode::run(ExecutionNode *previous)
 {
 	m_previousNode = previous;
-    if(NULL==previous)
-    {
-        return;
-    }
-    DiceResult* previous_result = dynamic_cast<DiceResult*>(previous->getResult());
-    if(NULL!=previous_result)
-    {
-        m_result->setPrevious(previous_result);
-        QList<Die*> diceList=previous_result->getResultList();
-        qint64 sum = 0;
-        foreach(Die* dice,diceList)
-        {
-            sum+=m_validator->hasValid(dice,true,true);
-        }
-        m_scalarResult->setValue(sum);
-
-
-        if(NULL!=m_nextNode)
-        {
-            m_nextNode->run(this);
-        }
-    }
+	if(NULL==previous)
+	{
+		return;
+	}
+	DiceResult* previous_result = dynamic_cast<DiceResult*>(previous->getResult());
+	if(NULL!=previous_result)
+	{
+		m_result->setPrevious(previous_result);
+		QList<Die*> diceList=previous_result->getResultList();
+		qint64 sum = 0;
+		foreach(Die* dice,diceList)
+		{
+			sum+=m_validator->hasValid(dice,true,true);
+		}
+		m_scalarResult->setValue(sum);
+
+
+		if(NULL!=m_nextNode)
+		{
+			m_nextNode->run(this);
+		}
+	}
 }
-QString CountExecuteNode::toString() const
+QString CountExecuteNode::toString(bool withlabel) const
 {
-    return "CountExecuteNode"+m_validator->toString();
+	if(withlabel)
+	{
+		return QString("%1 [label=\"CountExecuteNode %2\"]").arg(m_id).arg(m_validator->toString());
+	}
+	else
+	{
+		return m_id;
+	}
 }
 qint64 CountExecuteNode::getPriority() const
 {
-    qint64 priority=0;
-    if(NULL!=m_nextNode)
-    {
-        priority = m_nextNode->getPriority();
-    }
+	qint64 priority=0;
+	if(NULL!=m_nextNode)
+	{
+		priority = m_nextNode->getPriority();
+	}
 
 
-    return priority;
+	return priority;
 }
diff --git a/node/countexecutenode.h b/node/countexecutenode.h
index 519403b..167ee82 100644
--- a/node/countexecutenode.h
+++ b/node/countexecutenode.h
@@ -30,7 +30,7 @@ public:
      * @brief toString
      * @return
      */
-    virtual QString toString()const;
+    virtual QString toString(bool withLabel)const;
     /**
      * @brief getPriority
      * @return
diff --git a/node/dicerollernode.cpp b/node/dicerollernode.cpp
index 06148fc..d8fe49c 100644
--- a/node/dicerollernode.cpp
+++ b/node/dicerollernode.cpp
@@ -8,30 +8,7 @@
 #include <QTime>
 
 
-//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();
-//    }
-//}
-
-
-
-//////////////////////////////////////////////////
-/// \brief DiceRollerNode::DiceRollerNode
-//////////////////////////////////////////////////
 DiceRollerNode::DiceRollerNode(quint64 faces,qint64 offset)
     : m_faces(faces),m_diceResult(new DiceResult()),m_offset(offset)
 {
@@ -48,6 +25,11 @@ void DiceRollerNode::run(ExecutionNode* previous)
             m_diceCount = result->getResult(Result::SCALAR).toReal();
             m_result->setPrevious(result);
 
+            if(m_diceCount == 0)
+            {
+                m_errors.insert(NO_DICE_TO_ROLL,QObject::tr("No dice to roll"));
+            }
+
             for(quint64 i=0; i < m_diceCount ; ++i)
             {
                 Die* die = new Die();
@@ -61,19 +43,23 @@ void DiceRollerNode::run(ExecutionNode* previous)
                 m_nextNode->run(this);
             }
         }
-    }
-
-
-
+	}
 }
 
 quint64 DiceRollerNode::getFaces()
 {
     return m_faces;
 }
-QString DiceRollerNode::toString() const
+QString DiceRollerNode::toString(bool wl) const
 {
-    return QString("DiceRollerNode");
+	if(wl)
+	{
+		return QString("%1 [label=\"DiceRollerNode faces: %2\"]").arg(m_id).arg(m_faces);
+	}
+	else
+	{
+		return m_id;
+	}
 }
 qint64 DiceRollerNode::getPriority() const
 {
diff --git a/node/dicerollernode.h b/node/dicerollernode.h
index 726676e..808676f 100644
--- a/node/dicerollernode.h
+++ b/node/dicerollernode.h
@@ -2,35 +2,43 @@
 #define DICEROLLERNODE_H
 
 #include <Qt>
-#include <QRunnable>
-#include <QMutex>
 
 #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;
-//};
 
 /**
- * @brief The DiceRollerNode class
+ * @brief The DiceRollerNode class rolls dice of one kind.
  */
 class DiceRollerNode : public ExecutionNode
 {
 public:
+	/**
+	 * @brief DiceRollerNode builds an instance
+	 * @param faces, number of faces of dices
+	 * @param offset, first value of dice.
+	 */
     DiceRollerNode(quint64 faces, qint64 offset = 1);
 
+	/**
+	 * @brief run - starts to roll dice.
+	 */
     virtual void run(ExecutionNode*);
+	/**
+	 * @brief getFaces accessor
+	 * @return the face count
+	 */
     quint64 getFaces();
 
-     virtual QString toString()const;
+	/**
+	  * @brief toString
+	  * @param wl
+	  * @return use to generate dot tree;
+	  */
+	 virtual QString toString(bool wl)const;
+	/**
+	  * @brief getPriority
+	  * @return priority for dice roll: 4 (higher)
+	  */
      virtual qint64 getPriority() const;
 //private members
 private:
diff --git a/node/executionnode.cpp b/node/executionnode.cpp
index dba56fc..abcb7cf 100644
--- a/node/executionnode.cpp
+++ b/node/executionnode.cpp
@@ -1,13 +1,14 @@
 #include "executionnode.h"
 
+#include <QUuid>
+
 ExecutionNode::ExecutionNode()
-    : m_nextNode(NULL),m_result(NULL),m_previousNode(NULL)
+	: m_nextNode(NULL),m_result(NULL),m_previousNode(NULL),m_id(QString("\"%1\"").arg(QUuid::createUuid().toString()))
 {
 
 }
 ExecutionNode::~ExecutionNode()
 {
-
 	if(NULL!=m_result)
 	{
 		delete m_result;
@@ -53,19 +54,29 @@ ExecutionNode* ExecutionNode::getPreviousNode() const
 }
 void ExecutionNode::generateDotTree(QString& s)
 {
-    s.append(toString());
+	s.append(toString(true));
+	s.append(";\n");
+
     if(NULL!=m_nextNode)
     {
+		s.append(toString(false));
         s.append(" -> ");
-        s.append(m_nextNode->toString());
-        s.append(" [label=\"nextNode\"];\n");
+		s.append(m_nextNode->toString(false));
+		s.append(";\n");
+//        s.append(" [label=\"nextNode\"];\n");
         m_nextNode->generateDotTree(s);
     }
     else
     {
+		s.append(toString(false));
         s.append(" -> ");
-        s.append("NULL");
-        s.append(" [label=\"nextNode\"];\n");
+		s.append("NULL;\n");
+
+
+		s.append(toString(false));
+		s.append(" ->");
+		s.append(m_result->toString(false));
+		s.append(" [label=\"Result\"];\n");
 
         m_result->generateDotTree(s);
     }
diff --git a/node/executionnode.h b/node/executionnode.h
index 39d714b..2531ced 100644
--- a/node/executionnode.h
+++ b/node/executionnode.h
@@ -3,13 +3,14 @@
 
 #include "result/result.h"
 #include <QDebug>
+
 /**
  * @brief The ExecutionNode class
  */
 class ExecutionNode
 {
 public:
-    enum ERROR_CODE {NO_ERROR,DIE_RESULT_EXPECTED,BAD_SYNTAXE,ENDLESS_LOOP_ERROR,DIVIDE_BY_ZERO,NOTHING_UNDERSTOOD};
+    enum ERROR_CODE {NO_ERROR,DIE_RESULT_EXPECTED,BAD_SYNTAXE,ENDLESS_LOOP_ERROR,DIVIDE_BY_ZERO,NOTHING_UNDERSTOOD,NO_DICE_TO_ROLL,TOO_MANY_DICE};
     /**
      * @brief ExecutionNode
      */
@@ -46,7 +47,7 @@ public:
      * @brief toString
      * @return
      */
-    virtual QString toString()const=0;
+    virtual QString toString(bool withLabel)const=0;
     /**
      * @brief getPriority
      * @return
@@ -85,6 +86,8 @@ protected:
      * @brief m_errors
      */
     QMap<ExecutionNode::ERROR_CODE,QString> m_errors;
+
+	QString m_id;
 };
 
 #endif // EXECUTIONNODE_H
diff --git a/node/explosedicenode.cpp b/node/explosedicenode.cpp
index c0ebfe7..cdbeb6c 100644
--- a/node/explosedicenode.cpp
+++ b/node/explosedicenode.cpp
@@ -44,9 +44,16 @@ void ExploseDiceNode::setValidator(Validator* val)
 {
       m_validator = val;
 }
-QString ExploseDiceNode::toString() const
+QString ExploseDiceNode::toString(bool withlabel) const
 {
-    return QString("ExploseDiceNode [label=\"ExploseDiceNode %1\"]").arg(m_validator->toString());
+	if(withlabel)
+	{
+		return QString("%1 [label=\"ExploseDiceNode %2\"]").arg(m_id).arg(m_validator->toString());
+	}
+	else
+	{
+		return m_id;
+	}
 }
 qint64 ExploseDiceNode::getPriority() const
 {
diff --git a/node/explosedicenode.h b/node/explosedicenode.h
index f5d0f6e..65c0abd 100644
--- a/node/explosedicenode.h
+++ b/node/explosedicenode.h
@@ -16,7 +16,7 @@ public:
 	virtual ~ExploseDiceNode();
     virtual void run(ExecutionNode* previous = NULL);
     virtual void setValidator(Validator* );
-    virtual QString toString()const;
+	virtual QString toString(bool )const;
     virtual qint64 getPriority() const;
 
 protected:
diff --git a/node/helpnode.cpp b/node/helpnode.cpp
index dd5f087..6f3916a 100644
--- a/node/helpnode.cpp
+++ b/node/helpnode.cpp
@@ -34,8 +34,7 @@ void HelpNode::run(ExecutionNode* previous)
     {
         if(previous->getResult() == NULL)
         {
-            txtResult->setText(toString());
-
+			txtResult->setText(QObject::tr("Rolisteam Dice Parser:\nFull documentation at: %1").arg(m_path));
         }
         else
         {
@@ -49,9 +48,16 @@ void HelpNode::run(ExecutionNode* previous)
         m_nextNode->run(this);
     }
 }
-QString HelpNode::toString() const
+QString HelpNode::toString(bool wl) const
 {
-    return QObject::tr("Rolisteam Dice Parser:\nFull documentation at: %1 \n").arg(m_path);
+	if(wl)
+	{
+		return QString("%1 [label=\"Rolisteam Dice Parser:\nFull documentation at: %2\"]").arg(m_id).arg(m_path);
+	}
+	else
+	{
+		return m_id;
+	}
 }
 
 qint64 HelpNode::getPriority() const
diff --git a/node/helpnode.h b/node/helpnode.h
index be21b67..ba59f1f 100644
--- a/node/helpnode.h
+++ b/node/helpnode.h
@@ -45,7 +45,7 @@ public:
      * @brief toString
      * @return
      */
-    virtual QString toString()const;
+	virtual QString toString(bool )const;
     /**
      * @brief getPriority
      * @return
diff --git a/node/jumpbackwardnode.cpp b/node/jumpbackwardnode.cpp
index be759ce..b0a5c8e 100644
--- a/node/jumpbackwardnode.cpp
+++ b/node/jumpbackwardnode.cpp
@@ -34,9 +34,16 @@ qint64 JumpBackwardNode::getPriority() const
 {
     return 4;
 }
-QString JumpBackwardNode::toString() const
+QString JumpBackwardNode::toString(bool wl) const
 {
-    return QString("JumpBackwardNode");
+	if(wl)
+	{
+		return QString("%1 [label=\"JumpBackwardNode\"]").arg(m_id);
+	}
+	else
+	{
+		return m_id;
+	}
 }
 void JumpBackwardNode::run(ExecutionNode* previous)
 {
diff --git a/node/jumpbackwardnode.h b/node/jumpbackwardnode.h
index 469c64a..a89d0d3 100644
--- a/node/jumpbackwardnode.h
+++ b/node/jumpbackwardnode.h
@@ -43,7 +43,7 @@ public:
 	 * @brief toString
 	 * @return
 	 */
-	virtual QString toString() const;
+	virtual QString toString(bool) const;
 	/**
 	 * @brief getPriority
 	 * @return
diff --git a/node/keepdiceexecnode.cpp b/node/keepdiceexecnode.cpp
index a230107..64d53f0 100644
--- a/node/keepdiceexecnode.cpp
+++ b/node/keepdiceexecnode.cpp
@@ -43,6 +43,10 @@ m_previousNode = previous;
     {
         QList<Die*> diceList=previousDiceResult->getResultList();
         QList<Die*> diceList2 = diceList.mid(0,m_numberOfDice);
+        if(m_numberOfDice > 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()));
+        }
 
         foreach(Die* tmp,diceList.mid(m_numberOfDice,-1))
         {
@@ -60,9 +64,16 @@ void KeepDiceExecNode::setDiceKeepNumber(quint64 n)
 {
     m_numberOfDice = n;
 }
-QString KeepDiceExecNode::toString() const
+QString KeepDiceExecNode::toString(bool wl) const
 {
-    return QString("KeepDiceExecNode [label=\"KeepDiceExecNode %1\"]").arg(m_numberOfDice);
+	if(wl)
+	{
+		return QString("%1 [label=\"KeepDiceExecNode %2\"]").arg(m_id).arg(m_numberOfDice);
+	}
+	else
+	{
+		return m_id;
+	}
 }
 qint64 KeepDiceExecNode::getPriority() const
 {
diff --git a/node/keepdiceexecnode.h b/node/keepdiceexecnode.h
index 01f5028..f86daa5 100644
--- a/node/keepdiceexecnode.h
+++ b/node/keepdiceexecnode.h
@@ -34,7 +34,7 @@ public:
 
     virtual void run(ExecutionNode *previous);
     virtual void setDiceKeepNumber(quint64 );
-    virtual QString toString()const;
+	virtual QString toString(bool)const;
     virtual qint64 getPriority() const;
 private:
     quint64 m_numberOfDice;
diff --git a/node/listaliasnode.cpp b/node/listaliasnode.cpp
index 1809eac..9ced186 100644
--- a/node/listaliasnode.cpp
+++ b/node/listaliasnode.cpp
@@ -59,14 +59,23 @@ QString ListAliasNode::buildList() const
 	}
 	return result;
 }
-QString ListAliasNode::toString() const
+QString ListAliasNode::toString(bool wl) const
 {
-    QStringList resultList;
-    foreach(DiceAlias* key, *m_aliasList)
-    {
-        resultList <<  "{" <<key->getCommand() << key->getValue()<<  "}";
-    }
-    return QString("ListAliasNode [label=\"ListAliasNode %1\"]").arg(resultList.join(","));
+	QStringList resultList;
+	foreach(DiceAlias* key, *m_aliasList)
+	{
+		resultList <<  "{" <<key->getCommand() << key->getValue()<<  "}";
+	}
+
+	if(wl)
+	{
+		return QString("%1 [label=\"ListAliasNode %2\"]").arg(m_id).arg(resultList.join(","));
+	}
+	else
+	{
+		return m_id;
+	}
+
 
 }
 qint64 ListAliasNode::getPriority() const
diff --git a/node/listaliasnode.h b/node/listaliasnode.h
index e8f8b0f..2f83a1b 100644
--- a/node/listaliasnode.h
+++ b/node/listaliasnode.h
@@ -42,7 +42,7 @@ public:
 	 * @brief toString
 	 * @return
 	 */
-    virtual QString toString() const;
+	virtual QString toString(bool) const;
     /**
      * @brief buildList
      * @return
diff --git a/node/listsetrollnode.cpp b/node/listsetrollnode.cpp
index fdc17a5..9f15d36 100644
--- a/node/listsetrollnode.cpp
+++ b/node/listsetrollnode.cpp
@@ -22,7 +22,7 @@
 #include "die.h"
 
 ListSetRollNode::ListSetRollNode()
-    :m_diceResult(new DiceResult()),m_stringResult(new StringResult())
+    :m_diceResult(new DiceResult()),m_stringResult(new StringResult()),m_unique(false)
 {
     m_result = m_stringResult;
 }
@@ -39,19 +39,21 @@ QStringList ListSetRollNode::getList()
 {
     return m_values;
 }
-QString ListSetRollNode::toString() const
+QString ListSetRollNode::toString(bool wl) const
 {
-    return QString("ListSetRollNode [label=\"ListSetRoll list:%1\"]").arg(m_values.join(','));
+	if(wl)
+	{
+		return QString("%1 [label=\"ListSetRoll list:%2\"]").arg(m_id).arg(m_values.join(","));
+	}
+	else
+	{
+		return m_id;
+	}
+
 }
 qint64 ListSetRollNode::getPriority() const
 {
     qint64 priority=4;
-//    if(NULL!=m_nextNode)
-//    {
-//        priority = m_nextNode->getPriority();
-//    }
-
-
     return priority;
 }
 void ListSetRollNode::run(ExecutionNode* previous)
@@ -68,13 +70,10 @@ void ListSetRollNode::run(ExecutionNode* previous)
             for(quint64 i=0; i < diceCount ; ++i)
             {
                 Die* die = new Die();
-                die->setFaces(m_values.size());
+                computeFacesNumber(die);
                 die->roll();
                 m_diceResult->insertResult(die);
-                if(die->getValue()-1<m_values.size())
-                {
-                    rollResult << m_values[die->getValue()-1];
-                }
+                getValueFromDie(die,rollResult);
             }
             m_stringResult->setText(rollResult.join(","));
             if(NULL!=m_nextNode)
@@ -83,11 +82,64 @@ void ListSetRollNode::run(ExecutionNode* previous)
             }
         }
     }
-
-
-
 }
 void ListSetRollNode::setListValue(QStringList lirs)
 {
     m_values = lirs;
 }
+void ListSetRollNode::setUnique(bool u)
+{
+    m_unique = u;
+}
+void ListSetRollNode::setRangeList(QList<Range>& ranges)
+{
+    m_rangeList = ranges;
+}
+void ListSetRollNode::computeFacesNumber(Die* die)
+{
+    if(m_rangeList.isEmpty())
+    {
+        die->setFaces(m_values.size());
+    }
+    else
+    {
+        Q_ASSERT(m_values.size() == m_rangeList.size());
+        qint64 max;
+        int i=0;
+        foreach(Range range, m_rangeList)
+        {
+            if(((i==0)||(max<range.getEnd()))&&(range.isFullyDefined()))
+            {
+               // qDebug()<< range.isFullyDefined() << range.getEnd();
+                max= range.getEnd();
+            }
+            ++i;
+        }
+        //qDebug() << "set Faces"<<max;
+        die->setFaces(max);
+    }
+
+}
+void ListSetRollNode::getValueFromDie(Die* die,QStringList& rollResult)
+{
+    if(m_rangeList.isEmpty())
+    {
+        if(die->getValue()-1<m_values.size())
+        {
+            rollResult << m_values[die->getValue()-1];
+        }
+    }
+    else
+    {
+        Q_ASSERT(m_values.size() == m_rangeList.size());
+        int i=0;
+        foreach (Range range, m_rangeList)
+        {
+            if(range.hasValid(die,false))
+            {
+                rollResult << m_values[i];
+            }
+            ++i;
+        }
+    }
+}
diff --git a/node/listsetrollnode.h b/node/listsetrollnode.h
index 3102ade..5f381f5 100644
--- a/node/listsetrollnode.h
+++ b/node/listsetrollnode.h
@@ -27,6 +27,7 @@
 #include "executionnode.h"
 #include "result/diceresult.h"
 #include "result/stringresult.h"
+#include "range.h"
 /**
  * @brief The ListSetRollNode class is dedicated to pick up item from list.
  */
@@ -36,17 +37,25 @@ public:
     ListSetRollNode();
 	virtual ~ListSetRollNode();
     virtual void run(ExecutionNode* previous = NULL);
-    virtual QString toString()const;
+	virtual QString toString(bool)const;
     virtual qint64 getPriority() const;
     QStringList getList();
 
     void setListValue(QStringList);
+    void setUnique(bool );
+    void setRangeList(QList<Range>&);
+
+
+private:
+    void getValueFromDie(Die* die,QStringList& rollResult);
+    void computeFacesNumber(Die* die);
 
 private:
     QStringList m_values;
     DiceResult* m_diceResult;
     StringResult* m_stringResult;
-
+    bool m_unique;
+    QList<Range> m_rangeList;
 };
 
 #endif // LISTSETROLLNODE_H
diff --git a/node/numbernode.cpp b/node/numbernode.cpp
index c63aadf..e2da54f 100644
--- a/node/numbernode.cpp
+++ b/node/numbernode.cpp
@@ -44,9 +44,16 @@ void NumberNode::setNumber(qint64 a)
     m_scalarResult->setValue(a);
     m_number = a;
 }
-QString NumberNode::toString() const
+QString NumberNode::toString(bool withLabel) const
 {
-    return QString("NumberNode [label=\"NumberNode %1\"]").arg(m_number);
+    if(withLabel)
+	{
+		return QString("%1 [label=\"NumberNode %2\"]").arg(m_id).arg(m_number);
+	}
+	else
+	{
+		return m_id;
+	}
 }
 qint64 NumberNode::getPriority() const
 {
diff --git a/node/numbernode.h b/node/numbernode.h
index 3c43a51..50d29ad 100644
--- a/node/numbernode.h
+++ b/node/numbernode.h
@@ -34,7 +34,7 @@ public:
     NumberNode();
     void run(ExecutionNode* previous);
     void setNumber(qint64);
-virtual QString toString()const;
+    virtual QString toString(bool withLabel)const;
     virtual qint64 getPriority() const;
 private:
     qint64 m_number;
diff --git a/node/parenthesesnode.cpp b/node/parenthesesnode.cpp
index f81fc1c..f54a976 100644
--- a/node/parenthesesnode.cpp
+++ b/node/parenthesesnode.cpp
@@ -50,9 +50,16 @@ void ParenthesesNode::run(ExecutionNode* /*previous*/)
         m_nextNode->run(this);
     }
 }
-QString ParenthesesNode::toString() const
+QString ParenthesesNode::toString(bool b) const
 {
-    return "ParenthesesNode";
+	if(b)
+	{
+		return QString("%1 [label=\"ParenthesesNode\"]").arg(m_id);
+	}
+	else
+	{
+		return m_id;
+	}
 }
 qint64 ParenthesesNode::getPriority() const
 {
diff --git a/node/parenthesesnode.h b/node/parenthesesnode.h
index 999e7bd..fbb1caf 100644
--- a/node/parenthesesnode.h
+++ b/node/parenthesesnode.h
@@ -34,7 +34,7 @@ public:
     virtual void run(ExecutionNode* previous = NULL);
 
     void setInternelNode(ExecutionNode* node);
-    virtual QString toString()const;
+	virtual QString toString(bool)const;
     virtual qint64 getPriority() const;
 private:
     ExecutionNode* m_internalNode;
diff --git a/node/rerolldicenode.cpp b/node/rerolldicenode.cpp
index 038a3ec..ce8f109 100644
--- a/node/rerolldicenode.cpp
+++ b/node/rerolldicenode.cpp
@@ -46,9 +46,17 @@ void RerollDiceNode::setValidator(Validator* val)
 {
       m_validator = val;
 }
-QString RerollDiceNode::toString() const
+QString RerollDiceNode::toString(bool wl) const
 {
-    return QString("RerollDiceNode [label=\"RerollDiceNode validatior:%1\"").arg(m_validator->toString());
+	if(wl)
+	{
+		return QString("%1 [label=\"RerollDiceNode validatior: %2\"]").arg(m_id).arg(m_validator->toString());
+	}
+	else
+	{
+		return m_id;
+	}
+	//return QString("RerollDiceNode [label=\"RerollDiceNode validatior:%1\"");
 }
 void RerollDiceNode::setAddingMode(bool b)
 {
diff --git a/node/rerolldicenode.h b/node/rerolldicenode.h
index a97e448..f456bb3 100644
--- a/node/rerolldicenode.h
+++ b/node/rerolldicenode.h
@@ -39,7 +39,7 @@ public:
 	 * @brief toString
 	 * @return
 	 */
-    virtual QString toString()const;
+    virtual QString toString(bool )const;
 
 
 	/**
diff --git a/node/scalaroperatornode.cpp b/node/scalaroperatornode.cpp
index d532df0..f69cb01 100644
--- a/node/scalaroperatornode.cpp
+++ b/node/scalaroperatornode.cpp
@@ -138,7 +138,7 @@ qint64 ScalarOperatorNode::multiple(qint64 a,qint64 b)
 {
     return a*b;
 }
-QString ScalarOperatorNode::toString() const
+QString ScalarOperatorNode::toString(bool wl) const
 {
     QString op="";
     switch(m_operator)
@@ -159,7 +159,14 @@ QString ScalarOperatorNode::toString() const
             break;
 
     }
-    return QString("ScalarOperatorNode [label=\"ScalarOperatorNode %1\"").arg(op);
+	if(wl)
+	{
+		return QString("%1 [label=\"ScalarOperatorNode %2\"]").arg(m_id).arg(op);
+	}
+	else
+	{
+		return m_id;
+	}
 }
 qint64 ScalarOperatorNode::getPriority() const
 {
@@ -174,27 +181,31 @@ qint64 ScalarOperatorNode::getPriority() const
 }
 void ScalarOperatorNode::generateDotTree(QString& s)
 {
-    s.append(toString());
+	s.append(toString(true));
+	s.append(";\n");
+
     if(NULL!=m_nextNode)
     {
+		s.append(toString(false));
         s.append(" -> ");
-        s.append(m_nextNode->toString());
-        s.append(" [label=\"nextNode\"];\n");
+		s.append(m_nextNode->toString(false));
+		s.append(";\n");
         m_nextNode->generateDotTree(s);
     }
     else
     {
+		s.append(toString(false));
         s.append(" -> ");
-        s.append("NULL");
-        s.append(" [label=\"nextNode\"];\n");
+		s.append("NULL");
+		s.append(" [label=\"nextNode\"];\n");
     }
     QString str;
     str.append("\n");
     if(NULL!=m_internalNode)
     {
-        str.append(toString());
+		str.append(toString(false));
         str.append(" -> ");
-        str.append(m_internalNode->toString());
+		str.append(m_internalNode->toString(false));
         str.append(" [label=\"internalNode\"];\n");
         m_internalNode->generateDotTree(str);
     }
diff --git a/node/scalaroperatornode.h b/node/scalaroperatornode.h
index e43f6f8..ea0f7e1 100644
--- a/node/scalaroperatornode.h
+++ b/node/scalaroperatornode.h
@@ -42,7 +42,7 @@ public:
     bool setOperatorChar(QChar c);
     void setInternalNode(ExecutionNode* node);
 
-    virtual QString toString()const;
+    virtual QString toString(bool wl)const;
     virtual qint64 getPriority() const;
 
     void generateDotTree(QString& s);
@@ -60,9 +60,9 @@ private:
 
 private:
 	ScalarOperator m_operator;
+    ScalarResult* m_scalarResult;
     ExecutionNode* m_internalNode;
     QMap<QChar,ScalarOperator> m_scalarOperationList;
-    ScalarResult* m_scalarResult;
 };
 
 #endif // SCALAROPERATORNODE_H
diff --git a/node/sortresult.cpp b/node/sortresult.cpp
index 421beb3..d149507 100644
--- a/node/sortresult.cpp
+++ b/node/sortresult.cpp
@@ -105,9 +105,17 @@ void SortResultNode::setSortAscending(bool asc)
 {
     m_ascending = asc;
 }
-QString SortResultNode::toString() const
+QString SortResultNode::toString(bool wl) const
 {
-    return QString("SortResultNode [label=\"SortResultNode %1\"").arg(m_ascending ? "Ascending":"Descending");
+	if(wl)
+	{
+		return QString("%1 [label=\"SortResultNode %2\"]").arg(m_id).arg(m_ascending ? "Ascending":"Descending");
+	}
+	else
+	{
+		return m_id;
+	}
+
 }
 qint64 SortResultNode::getPriority() const
 {
diff --git a/node/sortresult.h b/node/sortresult.h
index d505e4b..c4f96dc 100644
--- a/node/sortresult.h
+++ b/node/sortresult.h
@@ -49,7 +49,7 @@ public:
      * @brief toString
      * @return
      */
-    virtual QString toString()const;
+    virtual QString toString(bool wl)const;
     /**
      * @brief getPriority
      * @return
diff --git a/node/startingnode.cpp b/node/startingnode.cpp
index 7e13f5d..5f1966e 100644
--- a/node/startingnode.cpp
+++ b/node/startingnode.cpp
@@ -32,10 +32,19 @@ void StartingNode::run(ExecutionNode*)
         m_nextNode->run(this);
     }
 }
-QString StartingNode::toString() const
+QString StartingNode::toString(bool withlabel) const
 {
-    return "StartingNode [shape=box]";
+	if(withlabel)
+	{
+		return QString("%1 [label=\"StartingNode\"]").arg(m_id);
+	}
+	else
+	{
+		return m_id;
+	}
 }
+
+
 qint64 StartingNode::getPriority() const
 {
     qint64 priority=0;
diff --git a/node/startingnode.h b/node/startingnode.h
index 1edebc9..923e84b 100644
--- a/node/startingnode.h
+++ b/node/startingnode.h
@@ -41,7 +41,7 @@ public:
      * @brief toString
      * @return
      */
-    virtual QString toString()const;
+    virtual QString toString(bool withlabel)const;
     /**
      * @brief getPriority
      * @return