fix some issue with parentheses management.

12 files changed, 224 insertions, 168 deletions

diff --git a/diceparser.cpp b/diceparser.cpp
index 5ddf172..0f5d231 100644
--- a/diceparser.cpp
+++ b/diceparser.cpp
@@ -49,33 +49,24 @@ ExecutionNode* DiceParser::getLatestNode(ExecutionNode* node)
 
 bool DiceParser::parseLine(QString str)
 {
-     m_command = str;
-     m_start = new StartingNode();
-     ExecutionNode* newNode = NULL;
+    m_command = str;
+    m_start = new StartingNode();
+    ExecutionNode* newNode = NULL;
+    m_current = m_start;
 
-   bool keepParsing = readExpression(str,newNode);
+    bool keepParsing = readExpression(str,newNode);
 
 
-    if(keepParsing)
+    while(keepParsing)
     {
-        m_start->setNextNode(newNode);
-//        if(NULL==m_start)
-//        {
-//            m_start = m_current;
-//        }
-
-
-
-        ExecutionNode* current = getLatestNode(m_start);
-
-
-
+        m_current->setNextNode(newNode);
+        m_current = getLatestNode(m_current);
         keepParsing =!str.isEmpty();
         if(keepParsing)
         {
-            keepParsing = readOperator(str,current);
+            keepParsing = readOperator(str,m_current);
 
-            current = getLatestNode(current);
+            m_current = getLatestNode(m_current);
         }
         return true;
     }
@@ -85,56 +76,97 @@ bool DiceParser::parseLine(QString str)
 
 bool DiceParser::readExpression(QString& str,ExecutionNode* & node)
 {
-    int myNumber = 1;
-    bool hasReadNumber=false;
+
+
+
+
+
+
+
+
+    //    int myNumber = 1;
+    //    bool hasReadNumber=false;
+    ExecutionNode* operandNode=NULL;
     if(m_parsingToolbox->readOpenParentheses(str))
     {
         ExecutionNode* internalNode=NULL;
         if(readExpression(str,internalNode))
         {
-                ParenthesesNode* parentheseNode  = new ParenthesesNode();
-                parentheseNode->setInternelNode(internalNode);
-                node = parentheseNode;
-                //node->setNextNode(parentheseNode);
-                if(m_parsingToolbox->readCloseParentheses(str))
+            ParenthesesNode* parentheseNode  = new ParenthesesNode();
+            parentheseNode->setInternelNode(internalNode);
+            node = parentheseNode;
+            if(m_parsingToolbox->readCloseParentheses(str))
+            {
+
+                ExecutionNode* diceNode=NULL;
+                if(readDice(str,diceNode))
                 {
-                    return true;
+                    parentheseNode->setNextNode(diceNode);
                 }
 
+                return true;
+            }
+
 
         }
     }
-    NumberNode* myNumberNode = NULL;
-    if(NULL==node)
+    else if(readOperand(str,operandNode))
     {
-        hasReadNumber= m_parsingToolbox->readNumber(str,myNumber);
+        ExecutionNode* diceNode=NULL;
+        if(readDice(str,diceNode))
+        {
+            operandNode->setNextNode(diceNode);
+        }
+        node = operandNode;
+
+        operandNode= getLatestNode(operandNode);
+        while(readOperator(str,operandNode));
 
-        myNumberNode = new NumberNode();
-        myNumberNode->setNumber(myNumber);
-    }
 
 
-    bool keepParsing = true;
-    ExecutionNode* execNode=NULL;
-    keepParsing = readDiceExpression(str,execNode);
-    if(NULL!=myNumberNode)
-    {
-        myNumberNode->setNextNode(execNode);
-        node = myNumberNode;
     }
     else
     {
-        node = execNode;
-    }
-    if(NULL!=execNode)
-    {
-        execNode = getLatestNode(execNode);
-        while(keepParsing)
+         ExecutionNode* diceNode=NULL;
+        if(readDice(str,diceNode))
         {
-            keepParsing = readOperator(str,execNode);
-            execNode = getLatestNode(execNode);
+            NumberNode* numberNode=new NumberNode();
+            numberNode->setNumber(1);
+            numberNode->setNextNode(diceNode);
+            node = numberNode;
         }
     }
+    //    NumberNode* myNumberNode = NULL;
+    //    if(NULL==node)
+    //    {
+    //        hasReadNumber= m_parsingToolbox->readNumber(str,myNumber);
+
+    //        myNumberNode = new NumberNode();
+    //        myNumberNode->setNumber(myNumber);
+    //    }
+
+
+    //    bool keepParsing = true;
+    //    ExecutionNode* execNode=NULL;
+    //    keepParsing = readDiceExpression(str,execNode);
+    //    if(NULL!=myNumberNode)
+    //    {
+    //        myNumberNode->setNextNode(execNode);
+    //        node = myNumberNode;
+    //    }
+    //    else
+    //    {
+    //        node = execNode;
+    //    }
+    //    if(NULL!=execNode)
+    //    {
+    //        execNode = getLatestNode(execNode);
+    //        while(keepParsing)
+    //        {
+    //            keepParsing = readOperator(str,execNode);
+    //            execNode = getLatestNode(execNode);
+    //        }
+    //    }
 
 
 
@@ -146,7 +178,7 @@ bool DiceParser::readExpression(QString& str,ExecutionNode* & node)
 
 void DiceParser::Start()
 {
-     m_start->run();
+    m_start->run();
 }
 void DiceParser::displayResult()
 {
@@ -214,7 +246,7 @@ void DiceParser::displayResult()
 
             if(!resulStr.isEmpty())
             {
-             stream << dieValue.arg(face).arg(resulStr);
+                stream << dieValue.arg(face).arg(resulStr);
             }
 
         }
@@ -224,9 +256,9 @@ void DiceParser::displayResult()
 
     QTextStream out(stdout);
     out << str << "you rolled: " <<m_command << endl;
+    out <<  endl;
 
-
-//qDebug() << "list:" << << " sum:" << << " command:" << command;
+    //qDebug() << "list:" << << " sum:" << << " command:" << command;
 }
 
 
@@ -241,9 +273,16 @@ bool DiceParser::readDice(QString&  str,ExecutionNode* & node)
         if(m_parsingToolbox->readNumber(str,num))
         {
             DiceRollerNode* drNode = new DiceRollerNode(num);
-//            dice.m_diceOp = myOperator;
-//            dice.m_faces = num;
+            //            dice.m_diceOp = myOperator;
+            //            dice.m_faces = num;
             node = drNode;
+            ExecutionNode* current = drNode;
+            while(readOption(str,current))
+            {
+                current = getLatestNode(current);
+            }
+
+
             return true;
         }
     }
@@ -271,41 +310,41 @@ bool DiceParser::readDiceExpression(QString& str,ExecutionNode* & node)
     bool returnVal=false;
 
 
-        /*ExecutionNode* operandeNode = NULL;
+    /*ExecutionNode* operandeNode = NULL;
         if(readExpression(str,operandeNode))
         {*/
-               // bool hasRead = m_parsingToolbox->readNumber(str,number);
+    // bool hasRead = m_parsingToolbox->readNumber(str,number);
 
 
 
 
-            /*NumberNode* numberNode = new NumberNode();
+    /*NumberNode* numberNode = new NumberNode();
             numberNode->setNumber(number);*/
 
 
 
-            ExecutionNode* next = NULL;
-            if(readDice(str,next))
-            {
-            //DiceRollerNode* next = addRollDiceNode(myDice.m_faces,operandeNode);
-            //numberNode->setNextNode(next); already done in addRollDiceNode method
-
+    ExecutionNode* next = NULL;
+    if(readDice(str,next))
+    {
+        //DiceRollerNode* next = addRollDiceNode(myDice.m_faces,operandeNode);
+        //numberNode->setNextNode(next); already done in addRollDiceNode method
 
 
 
-                ExecutionNode* latest = next;
-                while(readOption(str,latest))
-                {
-                    while(NULL!=latest->getNextNode())
-                    {
-                        latest = latest->getNextNode();
-                    }
-                }
 
-                node = next;
-                returnVal = true;
+        ExecutionNode* latest = next;
+        while(readOption(str,latest))
+        {
+            while(NULL!=latest->getNextNode())
+            {
+                latest = latest->getNextNode();
             }
-        /*    else if(NULL!=operandeNode)
+        }
+
+        node = next;
+        returnVal = true;
+    }
+    /*    else if(NULL!=operandeNode)
             {
                 //setCurrentNode(numberNode);
                 returnVal = true;
@@ -318,13 +357,13 @@ bool DiceParser::readDiceExpression(QString& str,ExecutionNode* & node)
                     }
                 }
             }*/
-            else
-            {
-                qDebug() << "error" << number << str;
-                returnVal = false;
-            }
+    else
+    {
+        qDebug() << "error" << number << str;
+        returnVal = false;
+    }
 
-      //  }
+    //  }
 
 
     return returnVal;
@@ -387,30 +426,30 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
 
             switch(m_OptionOp->value(tmp))
             {
-                case keep:
+            case keep:
+            {
+                int myNumber=0;
+                if(m_parsingToolbox->readNumber(str,myNumber))
                 {
-                    int myNumber=0;
-                    if(m_parsingToolbox->readNumber(str,myNumber))
+                    if(!hasDice)
                     {
-                        if(!hasDice)
-                        {
-                            previous = addRollDiceNode(10,previous);
-                        }
+                        previous = addRollDiceNode(10,previous);
+                    }
 
 
-                        node = m_parsingToolbox->addSort(previous,false);
+                    node = m_parsingToolbox->addSort(previous,false);
 
-                        KeepDiceExecNode* nodeK = new KeepDiceExecNode();
-                        nodeK->setDiceKeepNumber(myNumber);
+                    KeepDiceExecNode* nodeK = new KeepDiceExecNode();
+                    nodeK->setDiceKeepNumber(myNumber);
 
-                        node->setNextNode(nodeK);
-                        node = nodeK;
-                        isFine = true;
+                    node->setNextNode(nodeK);
+                    node = nodeK;
+                    isFine = true;
 
-                    }
                 }
-                    break;
-                case KeepAndExplose:
+            }
+                break;
+            case KeepAndExplose:
             {
                 int myNumber=0;
                 if(m_parsingToolbox->readNumber(str,myNumber))
@@ -433,56 +472,56 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
                 }
             }
                 break;
-                    break;
-                case Sort:
-                {
-                    node = m_parsingToolbox->addSort(previous,false);
+                break;
+            case Sort:
+            {
+                node = m_parsingToolbox->addSort(previous,false);
 
-                    isFine = true;
-                }
-                    break;
-                case Count:
+                isFine = true;
+            }
+                break;
+            case Count:
+            {
+                Validator* validator = m_parsingToolbox->readValidator(str);
+                if(NULL!=validator)
                 {
-                    Validator* validator = m_parsingToolbox->readValidator(str);
-                    if(NULL!=validator)
-                    {
-                        CountExecuteNode* countNode = new CountExecuteNode();
-                        countNode->setValidator(validator);
+                    CountExecuteNode* countNode = new CountExecuteNode();
+                    countNode->setValidator(validator);
 
-                        previous->setNextNode(countNode);
-                        node = countNode;
-                        isFine = true;
-                    }
+                    previous->setNextNode(countNode);
+                    node = countNode;
+                    isFine = true;
                 }
-                    break;
-                case Reroll:
+            }
+                break;
+            case Reroll:
+            {
+                Validator* validator = m_parsingToolbox->readValidator(str);
+                if(NULL!=validator)
                 {
-                    Validator* validator = m_parsingToolbox->readValidator(str);
-                    if(NULL!=validator)
-                    {
-                        RerollDiceNode* rerollNode = new RerollDiceNode();
-                        rerollNode->setValidator(validator);
-                        previous->setNextNode(rerollNode);
-                        node = rerollNode;
-                        isFine = true;
-
+                    RerollDiceNode* rerollNode = new RerollDiceNode();
+                    rerollNode->setValidator(validator);
+                    previous->setNextNode(rerollNode);
+                    node = rerollNode;
+                    isFine = true;
 
-                    }
 
                 }
-                    break;
-                case Explosing:
+
+            }
+                break;
+            case Explosing:
+            {
+                Validator* validator = m_parsingToolbox->readValidator(str);
+                if(NULL!=validator)
                 {
-                    Validator* validator = m_parsingToolbox->readValidator(str);
-                    if(NULL!=validator)
-                    {
-                        ExploseDiceNode* explosedNode = new ExploseDiceNode();
-                        explosedNode->setValidator(validator);
-                        previous->setNextNode(explosedNode);
-                        node = explosedNode;
-                        isFine = true;
-                    }
+                    ExploseDiceNode* explosedNode = new ExploseDiceNode();
+                    explosedNode->setValidator(validator);
+                    previous->setNextNode(explosedNode);
+                    node = explosedNode;
+                    isFine = true;
                 }
+            }
 
             }
         }
@@ -497,17 +536,34 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice)
 bool DiceParser::readOperand(QString& str,ExecutionNode* & node)
 {
     int myNumber=1;
+    ExecutionNode* myNode=NULL;
+
     if(m_parsingToolbox->readNumber(str,myNumber))
     {
+        NumberNode* myNumberNode = new NumberNode();
+        myNumberNode->setNumber(myNumber);
 
+        node = myNumberNode;
+        return true;
     }
-    if(readOperator(str,node))
-    {
+//    else if(readExpression(str,myNode))
+//    {
+
+//        if(readOperator(str,myNode))
+//        {
 
-       m_parsingToolbox->readNumber(str,myNumber);
-        /// @todo implements this
+//            if(readExpression(str,myNode))
+//            {
 
-    }
+//                m_parsingToolbox->readNumber(str,myNumber);
+//                /// @todo implements this
+//            }
+
+//        }
 
+//    }
 
+
+
+        return false;
 }
diff --git a/main.cpp b/main.cpp
index 47a7c45..1abb895 100644
--- a/main.cpp
+++ b/main.cpp
@@ -11,23 +11,23 @@ int main(int argc, char *argv[])
 
     QStringList commands;
 
-    commands << "2D10+(4*1D10)";
-//             << "3D100"
-//             << "10D10e[>=6]s"
-//             << "100190D6666666s"
-//             << "10D10e10s"
-//             << "10D10s"
-//             << "15D10e10c[8-10]"
-//             << "15D10c[>7]"
-//             << "1D8+2D6+7"
-//             << "D25"
-//             << "8+8+8"
-//             << "1D20-88"
-//             << "100*1D20*2D6"
-//             << "100/28*3"
-//             << "100/8"
-//             << "100*3*8"
-//             << "100*3*8";
+    commands <<"1+(4*3)D10"
+             << "3D100"
+             << "10D10e[>=6]s"
+             << "100190D6666666s"
+             << "10D10e10s"
+            << "10D10s"
+             << "15D10e10c[8-10]"
+             << "15D10c[>7]"
+             << "1D8+2D6+7"
+             << "D25"
+             << "8+8+8"
+             << "1D20-88"
+             << "100*1D20*2D6"
+             << "100/28*3"
+             << "100/8"
+             << "100*3*8"
+             << "100*3*8";
 
 
 
diff --git a/node/countexecutenode.cpp b/node/countexecutenode.cpp
index 6994b15..736aa92 100644
--- a/node/countexecutenode.cpp
+++ b/node/countexecutenode.cpp
@@ -15,7 +15,7 @@ void CountExecuteNode::setValidator(Validator* validator)
 
 void CountExecuteNode::run(ExecutionNode *previous)
 {
-         qDebug() << "CountExecuteNode node";
+//         qDebug() << "CountExecuteNode node";
     if(NULL==previous)
     {
         return;
diff --git a/node/dicerollernode.cpp b/node/dicerollernode.cpp
index 70fbe49..cc1bff7 100644
--- a/node/dicerollernode.cpp
+++ b/node/dicerollernode.cpp
@@ -14,7 +14,7 @@ DiceRollerNode::DiceRollerNode(quint64 faces)
 }
 void DiceRollerNode::run(ExecutionNode* previous)
 {
-       qDebug() << "DiceRollerNode node";
+//       qDebug() << "DiceRollerNode node";
     if(NULL!=previous)
     {
         Result* result=previous->getResult();
diff --git a/node/explosedicenode.cpp b/node/explosedicenode.cpp
index bf3eaee..469c9f6 100644
--- a/node/explosedicenode.cpp
+++ b/node/explosedicenode.cpp
@@ -8,7 +8,7 @@ ExploseDiceNode::ExploseDiceNode()
 void ExploseDiceNode::run(ExecutionNode* previous)
 {
 
-    qDebug() << "ExploseDiceNode node";
+//    qDebug() << "ExploseDiceNode node";
     if((NULL!=previous)&&(NULL!=previous->getResult()))
     {
         DiceResult* previous_result = static_cast<DiceResult*>(previous->getResult());
diff --git a/node/keepdiceexecnode.cpp b/node/keepdiceexecnode.cpp
index 62aefb6..ebe3941 100644
--- a/node/keepdiceexecnode.cpp
+++ b/node/keepdiceexecnode.cpp
@@ -12,7 +12,7 @@ KeepDiceExecNode::KeepDiceExecNode()
 
 void KeepDiceExecNode::run(ExecutionNode* previous)
 {
-     qDebug() << "KeepDiceExecNode node";
+//     qDebug() << "KeepDiceExecNode node";
     if(NULL==previous)
     {
         return;
diff --git a/node/numbernode.cpp b/node/numbernode.cpp
index b3bbaf0..4ab8a1c 100644
--- a/node/numbernode.cpp
+++ b/node/numbernode.cpp
@@ -8,7 +8,7 @@ NumberNode::NumberNode()
 void NumberNode::run(ExecutionNode* )
 {
 
-    qDebug() << "NumberNode node";
+//    qDebug() << "NumberNode node";
     if(NULL!=m_nextNode)
     {
         m_nextNode->run(this);
diff --git a/node/parenthesesnode.cpp b/node/parenthesesnode.cpp
index d87b258..3e5073d 100644
--- a/node/parenthesesnode.cpp
+++ b/node/parenthesesnode.cpp
@@ -10,7 +10,7 @@ void ParenthesesNode::setInternelNode(ExecutionNode* node)
 }
 void ParenthesesNode::run(ExecutionNode* /*previous*/)
 {
-    qDebug() << "ParenthesesNode node";
+//    qDebug() << "ParenthesesNode node";
     if(NULL!=m_internalNode)
     {
         m_internalNode->run(this);
diff --git a/node/rerolldicenode.cpp b/node/rerolldicenode.cpp
index 5e17d4b..2d764ae 100644
--- a/node/rerolldicenode.cpp
+++ b/node/rerolldicenode.cpp
@@ -8,7 +8,7 @@ RerollDiceNode::RerollDiceNode()
 }
 void RerollDiceNode::run(ExecutionNode* previous)
 {
-        qDebug() << "RerollDiceNode node";
+//        qDebug() << "RerollDiceNode node";
     if((NULL!=previous)&&(NULL!=previous->getResult()))
     {
         DiceResult* previous_result = static_cast<DiceResult*>(previous->getResult());
diff --git a/node/scalaroperatornode.cpp b/node/scalaroperatornode.cpp
index e473cc2..2abde1a 100644
--- a/node/scalaroperatornode.cpp
+++ b/node/scalaroperatornode.cpp
@@ -39,7 +39,7 @@ void ScalarOperatorNode::run(ExecutionNode* previous)
             m_result->setPrevious(internalResult);
             internalResult->setPrevious(previousResult);
 
-            qDebug() << "ScalarOperatorNode node" << m_myOperator;
+            //qDebug() << "ScalarOperatorNode node" << m_myOperator;
 
             switch(m_myOperator)
             {
diff --git a/node/sortresult.cpp b/node/sortresult.cpp
index 4111328..c75d5e3 100644
--- a/node/sortresult.cpp
+++ b/node/sortresult.cpp
@@ -12,7 +12,7 @@ SortResultNode::SortResultNode()
 }
 void SortResultNode::run(ExecutionNode* node)
 {
-    qDebug() << "SortResultNode node";
+//    qDebug() << "SortResultNode node";
     if(NULL==node)
     {
         return;
diff --git a/node/startingnode.cpp b/node/startingnode.cpp
index 7822bcc..d5e43ea 100644
--- a/node/startingnode.cpp
+++ b/node/startingnode.cpp
@@ -7,7 +7,7 @@ StartingNode::StartingNode()
 }
 void StartingNode::run(ExecutionNode*)
 {
-    qDebug() << "starting node";
+//    qDebug() << "starting node";
     if(NULL!=m_nextNode)
     {
         m_nextNode->run(this);