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

19 files changed, 136 insertions, 82 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 577e112..b654ea2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,8 +4,6 @@ cmake_minimum_required(VERSION 2.8)
 project(dice)
 
 #/net/rnd/src/qt/qt-everywhere-enterprise-src-5.3.0/linux-x86_64-gcc-4.7.2/lib/cmake
-set(CMAKE_PREFIX_PATH "/net/rnd/src/qt/qt-everywhere-enterprise-src-5.3.0/linux-x86_64-gcc-4.7.2/lib/cmake")
-
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}
 #${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}")
 
diff --git a/booleancondition.cpp b/booleancondition.cpp
index de619e7..533ec02 100644
--- a/booleancondition.cpp
+++ b/booleancondition.cpp
@@ -63,6 +63,11 @@ qint64 BooleanCondition::hasValid(Die* b,bool recursive,bool unhighlight) const
     {
         b->setHighlighted(false);
     }
+    else
+    {
+         b->setHighlighted(true);
+    }
+
     return sum;
 }
 
diff --git a/cli/main.cpp b/cli/main.cpp
index 7476eb4..0812059 100644
--- a/cli/main.cpp
+++ b/cli/main.cpp
@@ -31,48 +31,47 @@ QString diceToText(ExportedDiceResult& dice)
     QStringList resultGlobal;
     foreach(int face, dice.keys())
     {
-        QStringList result;
+           QStringList result;
            ListDiceResult diceResult =  dice.value(face);
-           bool previousHighlight=false;
-           QString patternColor("\e[0;31m");
            //patternColor = patternColorarg();
            foreach (DiceAndHighlight tmp, diceResult)
            {
                 QStringList diceListStr;
                 QStringList diceListChildren;
-                 if((previousHighlight)&&(!tmp.second))
-                {
-                    result << patternColor << result.join(',') <<"\e[0m";
-                }
-                 previousHighlight = tmp.second;
+
+
                 for(int i =0; i < tmp.first.size(); ++i)
                 {
                     quint64 dievalue = tmp.first[i];
+                    QString prefix("%1");
+
+                    if(tmp.second)
+                    {
+                        prefix = "\e[0;31m%1\e[0m";
+
+                    }
+
                     if(i==0)
                     {
-                        diceListStr << QString::number(dievalue);
+                        diceListStr << prefix.arg(QString::number(dievalue));
                     }
                     else
                     {
-                        diceListChildren << QString::number(dievalue);
+                        diceListChildren << prefix.arg(QString::number(dievalue));
                     }
                 }
                 if(!diceListChildren.isEmpty())
                 {
-                    diceListStr << QString("[%1]").arg(diceListChildren.join(','));
+                    diceListStr << QString("[%1]").arg(diceListChildren.join(' '));
                 }
 
                 result << diceListStr.join(' ');
+               // qDebug() << result << tmp.first << tmp.second;
            }
-           if(previousHighlight)
-           {
-               QStringList list;
-               list << patternColor << result.join(',') << "\e[0m";
-               result = list;
-           }
+
            if(dice.keys().size()>1)
            {
-              resultGlobal << QString(" d%2:(%1)").arg(result.join(' ')).arg(face);
+              resultGlobal << QString(" d%2:(%1)").arg(result.join(',')).arg(face);
            }
            else
            {
@@ -88,10 +87,10 @@ void startDiceParsing(QString& cmd,QString& treeFile,bool highlight)
 
     if(parser->parseLine(cmd))
     {
-        parser->Start();
        //
         if(treeFile.isEmpty())
         {
+            parser->Start();
             ExportedDiceResult list;
             parser->getLastDiceResult(list);
             QString diceText = diceToText(list);
@@ -114,13 +113,16 @@ void startDiceParsing(QString& cmd,QString& treeFile,bool highlight)
                 str = parser->getStringResult().replace("\n","<br/>");
             }
             qDebug() << str;
-
         }
         else
         {
             parser->writeDownDotTree(treeFile);
         }
     }
+    else
+    {
+        qDebug() << parser->humanReadableError();
+    }
 }
 
 
@@ -128,15 +130,19 @@ void startDiceParsing(QString& cmd,QString& treeFile,bool highlight)
 
 int main(int argc, char *argv[])
 {
+    //QCoreApplication app(argc,argv);
+    //QCoreApplication::setApplicationName("dice");
+    //QCoreApplication::setApplicationVersion("1.0");
+
 
     QStringList commands;
     QString cmd;
     QString dotFileStr;
 
-    bool colorb=false;
+    bool colorb=true;
 
     QCommandLineParser optionParser;
-    QCommandLineOption color(QStringList() << "co"<< "color-off", "Disable color to highlight result");
+    QCommandLineOption color(QStringList() << "c"<< "color-off", "Disable color to highlight result");
     QCommandLineOption version(QStringList() << "v"<< "version", "Show the version and quit.");
     QCommandLineOption reset(QStringList() << "reset-settings", "Erase the settings and use the default parameters");
     QCommandLineOption dotFile(QStringList() << "d"<<"dot-file", "Instead of rolling dice, generate the execution tree and write it in <dotfile>","dotfile");
@@ -154,25 +160,20 @@ int main(int argc, char *argv[])
     optionParser.addOption(translation);
     optionParser.addOption(help);
 
-    for(int i=1;i<argc;++i)
+    for(int i=0;i<argc;++i)
     {
 
         commands << QString::fromLatin1(argv[i]);
     }
 
-    if(!optionParser.parse(commands))
-    {
-        qDebug()<< optionParser.errorText();
-    }
-    else
-         {
-        qDebug() << "no error";
-    }
+    optionParser.process(commands);
+
+
 
 
     if(optionParser.isSet(color))
     {
-        qDebug() << "color";
+        commands.removeAt(0);
         colorb = false;
     }
     else if(optionParser.isSet(version))
@@ -195,11 +196,17 @@ int main(int argc, char *argv[])
     {
         cmd = "help";
     }
+    QStringList cmdList = optionParser.positionalArguments();
+   // qDebug()<< "rest"<< cmdList;
 
-    cmd = commands.first();
-
-    qDebug() << "super 5" << cmd << dotFileStr << colorb;
-    startDiceParsing(cmd,dotFileStr,colorb);
+    if(!cmdList.isEmpty())
+    {
+        cmd = cmdList.first();
+    }
+    if(!cmd.isEmpty())
+    {
+        startDiceParsing(cmd,dotFileStr,colorb);
+    }
 
     /*commands<< "10d10c[>6]+@c[=10]"
 			<< "1L[cheminée,chocolat,épée,arc,chute de pierre]"
diff --git a/diceparser.cpp b/diceparser.cpp
index c710f55..a946b86 100644
--- a/diceparser.cpp
+++ b/diceparser.cpp
@@ -221,9 +221,6 @@ bool DiceParser::readExpression(QString& str,ExecutionNode* & node)
 
         operandNode= getLatestNode(operandNode);
         while(readOperator(str,operandNode));
-
-
-
     }
     else if(readCommand(str,operandNode))
     {
@@ -405,7 +402,6 @@ void DiceParser::getLastDiceResult(ExportedDiceResult& diceValues)
     {
         if(result->hasResultOfType(Result::DICE_LIST))
         {
-
             DiceResult* diceResult = dynamic_cast<DiceResult*>(result);
             if(NULL!=diceResult)
             {
@@ -604,7 +600,7 @@ bool DiceParser::readDiceExpression(QString& str,ExecutionNode* & node)
     ExecutionNode* next = NULL;
     if(readDice(str,next))
     {
-         ExecutionNode* latest = next;
+        ExecutionNode* latest = next;
         while(readOption(str,latest))
         {
             while(NULL!=latest->getNextNode())
@@ -685,30 +681,13 @@ bool DiceParser::readOperator(QString& str,ExecutionNode* previous)
 
            return true;
        }
-
-
-
     }
     else
     {
         delete node;
-        ExecutionNode* nodeExec = new  DiceRollerNode(DEFAULT_FACES_NUMBER);
-        ExecutionNode* nodeExec2 = nodeExec;
-        bool readOptionSuccessed=false;
-        while(readOption(str,nodeExec))
+        while(readOption(str,previous,false))
         {
-           nodeExec = getLatestNode(nodeExec);
-           readOptionSuccessed = true;
-        }
-        if(readOptionSuccessed)
-        {
-            previous->setNextNode(nodeExec2);
-        }
-        else
-        {
-            delete nodeExec;
-            nodeExec = NULL;
-            nodeExec2 = NULL;
+           previous = getLatestNode(previous);
         }
     }
     return false;
@@ -730,7 +709,7 @@ ExploseDiceNode* DiceParser::addExploseDiceNode(qint64 value,ExecutionNode* prev
     previous->setNextNode(exploseDiceNode);
     return exploseDiceNode;
 }
-bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
+bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)//,
 {
     if(str.isEmpty())
     {
@@ -748,7 +727,7 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
         {
 
             str=str.remove(0,tmp.size());
-
+        //    option = m_OptionOp->value(tmp);
             switch(m_OptionOp->value(tmp))
             {
             case Keep:
@@ -759,7 +738,7 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
                 {
                     if(!hasDice)
                     {
-                        previous = addRollDiceNode(10,previous);
+                        previous = addRollDiceNode(DEFAULT_FACES_NUMBER,previous);
                     }
                     node = m_parsingToolbox->addSort(previous,ascending);
 
@@ -769,7 +748,6 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
                     node->setNextNode(nodeK);
                     node = nodeK;
                     isFine = true;
-
                 }
             }
                 break;
@@ -781,7 +759,7 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
                 {
                     if(!hasDice)
                     {
-                        previous = addRollDiceNode(10,previous);
+                        previous = addRollDiceNode(DEFAULT_FACES_NUMBER,previous);
                     }
                     DiceRollerNode* nodeTmp = dynamic_cast<DiceRollerNode*>(previous);
 
@@ -795,7 +773,6 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
                     node->setNextNode(nodeK);
                     node = nodeK;
                     isFine = true;
-
                 }
             }
                 break;
@@ -803,7 +780,10 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
             {
                 bool ascending = m_parsingToolbox->readAscending(str);
                 node = m_parsingToolbox->addSort(previous,ascending);
-
+                /*if(!hasDice)
+                {
+                    m_errorMap.insert(ExecutionNode::BAD_SYNTAXE,QObject::tr("Sort Operator does not support default dice. You should add dice command before the s"));
+                }*/
                 isFine = true;
             }
                 break;
@@ -845,8 +825,6 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
                     previous->setNextNode(rerollNode);
                     node = rerollNode;
                     isFine = true;
-
-
                 }
                 else
                 {
diff --git a/diceparser.h b/diceparser.h
index 4031bdc..7cf72de 100644
--- a/diceparser.h
+++ b/diceparser.h
@@ -222,7 +222,7 @@ private:
     /**
      * @brief readOption
      */
-    bool readOption(QString&,ExecutionNode* node, bool hasDice = true);
+    bool readOption(QString&,ExecutionNode* node, bool hasDice = true);//OptionOperator& option,
 
 	/**
 	 * @brief addRollDiceNode
diff --git a/die.cpp b/die.cpp
index 2a70bc0..4782705 100644
--- a/die.cpp
+++ b/die.cpp
@@ -41,6 +41,7 @@ Die::Die(const Die& die)
     m_hasValue = die.m_hasValue;
     m_displayStatus = die.m_displayStatus;
     m_faces = die.m_faces;
+    m_highlighted = die.m_highlighted;
 }
 
 void Die::setValue(qint64 r)
diff --git a/node/executionnode.cpp b/node/executionnode.cpp
index 343e8d9..0cb9c0b 100644
--- a/node/executionnode.cpp
+++ b/node/executionnode.cpp
@@ -59,5 +59,7 @@ void ExecutionNode::generateDotTree(QString& s)
         s.append(" -> ");
         s.append("NULL");
         s.append(" [label=\"nextNode\"];\n");
+
+        m_result->generateDotTree(s);
     }
 }
diff --git a/node/executionnode.h b/node/executionnode.h
index cf1514f..cc40867 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,ENDLESS_LOOP_ERROR};
+    enum ERROR_CODE {NO_ERROR,DIE_RESULT_EXPECTED,BAD_SYNTAXE,ENDLESS_LOOP_ERROR,DIVIDE_BY_ZERO};
     /**
      * @brief ExecutionNode
      */
diff --git a/node/jumpbackwardnode.cpp b/node/jumpbackwardnode.cpp
index af96ed8..d800394 100644
--- a/node/jumpbackwardnode.cpp
+++ b/node/jumpbackwardnode.cpp
@@ -1,5 +1,5 @@
 #include "jumpbackwardnode.h"
-
+#include <QDebug>
 
 JumpBackwardNode::JumpBackwardNode()
 {
@@ -32,12 +32,15 @@ void JumpBackwardNode::run(ExecutionNode* previous)
             if((NULL!=result))
 			{
 				--i;
-                if((i==0)&&(parent->getResult()->hasResultOfType(Result::DICE_LIST)))
+                if((i==0)&&(result->hasResultOfType(Result::DICE_LIST)))
 				{
 					found =true;
 				}
 			}
-			parent = parent->getPreviousNode();
+            if(!found)
+            {
+                parent = parent->getPreviousNode();
+            }
 
 		}
         DiceResult* diceResult = dynamic_cast<DiceResult*>(result);
@@ -46,13 +49,27 @@ void JumpBackwardNode::run(ExecutionNode* previous)
             Die* tmpdie = new Die();
             *tmpdie=*die;
             m_diceResult->insertResult(tmpdie);
+            die->displayed();
         }
 
-        //*m_result = *result;
+
         m_result->setPrevious(parent->getResult());
 
+
+
         if(NULL!=m_nextNode)
         {
             m_nextNode->run(this);
         }
+        for(int i =0;i<diceResult->getResultList().size();++i)
+        {
+            Die* tmp =diceResult->getResultList().at(i);
+            Die* tmp2 =m_diceResult->getResultList().at(i);
+            if(tmp->isHighlighted())
+            {
+                tmp2->setHighlighted(true);
+            }
+        }
+
+
 }
diff --git a/node/scalaroperatornode.cpp b/node/scalaroperatornode.cpp
index 34eb6b8..8dfbc20 100644
--- a/node/scalaroperatornode.cpp
+++ b/node/scalaroperatornode.cpp
@@ -105,6 +105,11 @@ qint64 ScalarOperatorNode::substract(qint64 a,qint64 b)
 
 qreal ScalarOperatorNode::divide(qint64 a,qint64 b)
 {
+    if(b==0)
+    {
+        m_errors.append(DIVIDE_BY_ZERO);
+        return 0;
+    }
     return (qreal)a/b;
 }
 
diff --git a/node/sortresult.cpp b/node/sortresult.cpp
index 46e6eb8..deaf794 100644
--- a/node/sortresult.cpp
+++ b/node/sortresult.cpp
@@ -80,7 +80,8 @@ void SortResultNode::run(ExecutionNode* node)
     }
     else
     {
-            m_errors.append(DIE_RESULT_EXPECTED);
+        m_result = node->getResult();
+        //m_errors.append(DIE_RESULT_EXPECTED);
     }
 
 }
diff --git a/result/diceresult.cpp b/result/diceresult.cpp
index f87079a..95122f1 100644
--- a/result/diceresult.cpp
+++ b/result/diceresult.cpp
@@ -82,3 +82,12 @@ qreal DiceResult::getScalarResult()
 
     return 0;
 }
+QString DiceResult::toString()
+{
+    QStringList scalarSum;
+    foreach(Die* die,m_diceValues)
+    {
+        scalarSum << QString::number(die->getValue());
+    }
+    return QString("DiceResult_Value_%1_dice_%2").arg(getScalarResult()).arg(scalarSum.join('_'));
+}
diff --git a/result/diceresult.h b/result/diceresult.h
index b805e73..07378d1 100644
--- a/result/diceresult.h
+++ b/result/diceresult.h
@@ -61,6 +61,11 @@ public:
      * @return
      */
     virtual QVariant getResult(RESULT_TYPE);
+    /**
+     * @brief toString
+     * @return
+     */
+    virtual QString toString();
 
 private:
     qreal getScalarResult();
diff --git a/result/result.cpp b/result/result.cpp
index 3acca93..257045c 100644
--- a/result/result.cpp
+++ b/result/result.cpp
@@ -48,9 +48,21 @@ bool Result::hasResultOfType(RESULT_TYPE type) const
 void Result::generateDotTree(QString& s)
 {
     s.append(toString());
+    if(NULL!=m_previous)
+    {
+        s.append(" -> ");
+        s.append(m_previous->toString());
+        s.append(" [label=\"previousResult\"];\n");
+        m_previous->generateDotTree(s);
+    }
+    {
+        s.append(" -> ");
+        s.append("NULL");
+        s.append(" [label=\"previousResult\"];\n");
+    }
 
 }
-QString Result::toString()
+/*QString Result::toString()
 {
     return QString();
-}
+}*/
diff --git a/result/result.h b/result/result.h
index dcd0b8d..3d635bc 100644
--- a/result/result.h
+++ b/result/result.h
@@ -77,7 +77,7 @@ public:
      * @brief toString
      * @return
      */
-    QString toString();
+    virtual QString toString() = 0;
 protected:
      int m_resultTypes;/// @brief
 private:
diff --git a/result/scalarresult.cpp b/result/scalarresult.cpp
index 8c924fe..a998608 100644
--- a/result/scalarresult.cpp
+++ b/result/scalarresult.cpp
@@ -36,3 +36,7 @@ QVariant ScalarResult::getResult(Result::RESULT_TYPE type)
     return m_value;
 }
 
+QString ScalarResult::toString()
+{
+    return QString("ScalarResult_Value_%1").arg(m_value);
+}
diff --git a/result/scalarresult.h b/result/scalarresult.h
index 35982be..4d64a90 100644
--- a/result/scalarresult.h
+++ b/result/scalarresult.h
@@ -35,6 +35,8 @@ public:
 
     void setValue(qreal i);
 
+    virtual QString toString();
+
 private:
     qreal m_value;
 };
diff --git a/result/stringresult.cpp b/result/stringresult.cpp
index 9f7d2e1..4dbd577 100644
--- a/result/stringresult.cpp
+++ b/result/stringresult.cpp
@@ -31,3 +31,7 @@ QVariant StringResult::getResult(RESULT_TYPE type)
 
     return QVariant();
 }
+QString StringResult::toString()
+{
+    return QString("StringResult_value_%1").arg(getText().replace(" ","_"));
+}
diff --git a/result/stringresult.h b/result/stringresult.h
index 17c43cd..4a9a4a4 100644
--- a/result/stringresult.h
+++ b/result/stringresult.h
@@ -32,7 +32,11 @@ public:
      * @return
      */
     virtual QVariant getResult(RESULT_TYPE);
-
+    /**
+     * @brief toString
+     * @return
+     */
+    virtual QString toString();
 private:
     QString m_value;
 };