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 --- HelpMe.md | 16 +++- booleancondition.cpp | 16 ++++ booleancondition.h | 2 + diceparser.cpp | 227 +++++++++++++++++++++++++++++++++++++++++++----- diceparser.h | 46 ++++++++-- diceparser.pri | 65 ++++++++++++++ node/dicerollernode.cpp | 32 +++---- node/dicerollernode.h | 22 ++--- node/executionnode.h | 2 +- node/helpnode.cpp | 2 +- node/node.pri | 52 +++++------ node/sortresult.cpp | 3 - parsingtoolbox.cpp | 32 +++++++ parsingtoolbox.h | 20 +++++ range.cpp | 5 ++ range.h | 1 + validator.h | 1 + 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(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) { 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 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* m_mapDiceOp; QMap* m_OptionOp; @@ -179,6 +213,8 @@ private: QMap* m_aliasMap; QList* m_commandList; + QMap 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 -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: https://github.com/obiwankennedy/DiceParser/blob/master/HelpMe.md \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())getFaces()); +} +DiceRollerNode* ParsingToolBox::getDiceRollerNode(ExecutionNode* previous) +{ + while(NULL!=previous) + { + DiceRollerNode* node = dynamic_cast(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 #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* 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 -- 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(-) 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