From 4c9a68db5423c5d798d178d4dafb5bf8e3228ed1 Mon Sep 17 00:00:00 2001 From: Renaud G Date: Tue, 31 Mar 2015 23:49:35 +0200 Subject: add better error management (not finished yet) add check for endless loop in validator (not finished yet) Better helpMe --- diceparser.cpp | 227 +++++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 206 insertions(+), 21 deletions(-) (limited to 'diceparser.cpp') 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(myResult); + DiceResult* myDiceResult = dynamic_cast(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(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(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; ((ikeys().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(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 DiceParser::getErrorList() { return m_start->getErrorList(); } +QString DiceParser::humanReadableError() +{ + QMapIterator i(m_errorMap); + QString str=""; + while (i.hasNext()) + { + i.next(); + str.append(i.value()); + str.append("\n"); + } +} bool DiceParser::readOperand(QString& str,ExecutionNode* & node) { -- cgit v1.2.3-70-g09d2 From 60a0e524561ae86c9509c61b00a5d8ba40a1d7ee Mon Sep 17 00:00:00 2001 From: Renaud G Date: Wed, 1 Apr 2015 00:28:17 +0200 Subject: -Better understanding of validators toString method -return error if error have been detected for endless loop. -add listaliasnode.h/.cpp to the pri file -protect the use of pointer --- booleancondition.cpp | 21 ++++++++++++++++++++- diceparser.cpp | 18 +++++++++++++----- diceparser.h | 46 ++++++++++++++++++++++++++++++++++++++++++---- diceparser.pri | 2 ++ parsingtoolbox.cpp | 9 ++++++++- range.cpp | 2 +- 6 files changed, 86 insertions(+), 12 deletions(-) (limited to 'diceparser.cpp') diff --git a/booleancondition.cpp b/booleancondition.cpp index af4ad10..267d7e9 100644 --- a/booleancondition.cpp +++ b/booleancondition.cpp @@ -77,7 +77,26 @@ void BooleanCondition::setValue(qint64 v) } QString BooleanCondition::toString() { - return QString("BooleanCondition_op_%1_value_%2").arg(m_operator).arg(m_value); + QString str=""; + switch (m_operator) + { + case Equal: + str.append("="); + break; + case GreaterThan: + str.append(">"); + break; + case LesserThan: + str.append("<"); + break; + case GreaterOrEqual: + str.append(">="); + break; + case LesserOrEqual: + str.append("<="); + break; + } + return QString("[%1%2]").arg(str).arg(m_value); } quint8 BooleanCondition::getValidRangeSize(quint64 faces) const { diff --git a/diceparser.cpp b/diceparser.cpp index 9404f08..91e4af0 100644 --- a/diceparser.cpp +++ b/diceparser.cpp @@ -100,6 +100,7 @@ QString DiceParser::convertAlias(QString str) bool DiceParser::parseLine(QString str) { + m_errorMap.clear(); m_command = str; m_start = new StartingNode(); ExecutionNode* newNode = NULL; @@ -108,7 +109,7 @@ bool DiceParser::parseLine(QString str) str = convertAlias(str); bool keepParsing = readExpression(str,newNode); - while(keepParsing) + if(keepParsing) { m_current->setNextNode(newNode); m_current = getLatestNode(m_current); @@ -119,10 +120,16 @@ bool DiceParser::parseLine(QString str) m_current = getLatestNode(m_current); } - return true; + } + if(m_errorMap.isEmpty()) + { + return true; + } + else + { + return false; } - return false; } @@ -785,9 +792,9 @@ bool DiceParser::readOption(QString& str,ExecutionNode* previous, bool hasDice) Validator* validator = m_parsingToolbox->readValidator(str); if(NULL!=validator) { - if(m_parsingToolbox->isValidValidator(previous,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())) + m_errorMap.insert(ExecutionNode::ENDLESS_LOOP_ERROR,QObject::tr("This condition %1 introduces an endless loop. Please, change it").arg(validator->toString())); } ExploseDiceNode* explosedNode = new ExploseDiceNode(); explosedNode->setValidator(validator); @@ -819,6 +826,7 @@ QString DiceParser::humanReadableError() str.append(i.value()); str.append("\n"); } + return str; } bool DiceParser::readOperand(QString& str,ExecutionNode* & node) diff --git a/diceparser.h b/diceparser.h index 6dd2a10..e4ea0e3 100644 --- a/diceparser.h +++ b/diceparser.h @@ -110,18 +110,50 @@ public: * @brief displayDotTree */ void displayDotTree(); - + /** + * @brief getLastIntegerResult + * @return + */ qreal getLastIntegerResult(); + /** + * @brief getSumOfDiceResult + * @return + */ qreal getSumOfDiceResult(); - + /** + * @brief getLastDiceResult + * @return + */ QString getLastDiceResult(); - + /** + * @brief hasIntegerResultNotInFirst + * @return + */ bool hasIntegerResultNotInFirst(); + /** + * @brief hasDiceResult + * @return + */ bool hasDiceResult(); + /** + * @brief getDiceCommand + * @return + */ QString getDiceCommand(); + /** + * @brief hasStringResult + * @return + */ bool hasStringResult(); + /** + * @brief getStringResult + * @return + */ QString getStringResult(); - + /** + * @brief humanReadableError + * @return + */ QString humanReadableError(); private: @@ -171,6 +203,12 @@ private: * @return */ DiceRollerNode* addRollDiceNode(qint64 faces,ExecutionNode*); + /** + * @brief addExploseDiceNode + * @param faces + * @param previous + * @return + */ ExploseDiceNode* addExploseDiceNode(qint64 faces,ExecutionNode* previous); /** * @brief readOperand diff --git a/diceparser.pri b/diceparser.pri index bf9847e..b9af1d7 100644 --- a/diceparser.pri +++ b/diceparser.pri @@ -42,6 +42,7 @@ HEADERS += \ $$PWD/node/parenthesesnode.h \ $$PWD/node/helpnode.h \ $$PWD/node/jumpbackwardnode.h \ + $$PWD/node/listaliasnode.h \ $$PWD/node/listsetrollnode.h SOURCES += \ @@ -58,6 +59,7 @@ SOURCES += \ $$PWD/node/parenthesesnode.cpp \ $$PWD/node/helpnode.cpp \ $$PWD/node/jumpbackwardnode.cpp \ + $$PWD/node/listaliasnode.cpp \ $$PWD/node/listsetrollnode.cpp diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp index f276abf..e03690e 100644 --- a/parsingtoolbox.cpp +++ b/parsingtoolbox.cpp @@ -204,7 +204,14 @@ bool ParsingToolBox::readAscending(QString& str) bool ParsingToolBox::isValidValidator(ExecutionNode* previous, Validator* val) { DiceRollerNode* node = getDiceRollerNode(previous); - return (val->getValidRangeSize(node->getFaces())getFaces()); + if(NULL!=node) + { + return (val->getValidRangeSize(node->getFaces())getFaces()); + } + else + { + return true; + } } DiceRollerNode* ParsingToolBox::getDiceRollerNode(ExecutionNode* previous) { diff --git a/range.cpp b/range.cpp index 712590f..1f47c50 100644 --- a/range.cpp +++ b/range.cpp @@ -54,7 +54,7 @@ qint64 Range::hasValid(Die* m,bool recursive) const } QString Range::toString() { - return QString("Range_%1_%2").arg(m_start).arg(m_end); + return QString("[%1-%2]").arg(m_start).arg(m_end); } quint8 Range::getValidRangeSize(quint64 faces) const { -- cgit v1.2.3-70-g09d2