diff options
Diffstat (limited to 'src/libparser/include/diceparser')
| -rw-r--r-- | src/libparser/include/diceparser/dicealias.h | 122 | ||||
| -rw-r--r-- | src/libparser/include/diceparser/diceparser.h | 130 | ||||
| -rw-r--r-- | src/libparser/include/diceparser/diceparser_global.h | 11 | ||||
| -rw-r--r-- | src/libparser/include/diceparser/diceparserhelper.h | 96 | ||||
| -rw-r--r-- | src/libparser/include/diceparser/highlightdice.h | 68 | ||||
| -rw-r--r-- | src/libparser/include/diceparser/parsingtoolbox.h | 284 |
6 files changed, 711 insertions, 0 deletions
diff --git a/src/libparser/include/diceparser/dicealias.h b/src/libparser/include/diceparser/dicealias.h new file mode 100644 index 0000000..05d5a0b --- /dev/null +++ b/src/libparser/include/diceparser/dicealias.h @@ -0,0 +1,122 @@ +/*************************************************************************** + * Copyright (C) 2014 by Renaud Guezennec * + * https://rolisteam.org/contact * + * * + * This file is part of DiceParser * + * * + * DiceParser is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ +#ifndef DICEALIAS_H +#define DICEALIAS_H + +#include <QString> + +#include <diceparser/diceparser_global.h> +/** + * @brief The DiceAlias class is dedicated to store aliases, alias is mainly two QString. The Alias and its replacement. + * The replacement can be a simple QString or a RegExp. + */ +class DICEPARSER_EXPORT DiceAlias +{ +public: + enum RESOLUTION_TYPE + { + REPLACE, + REGEXP + }; + /** + * @brief DiceAlias + * @param cmd + * @param key + * @param isReplace + */ + DiceAlias(QString pattern, QString command, QString comment= QString{}, bool isReplace= true, bool isEnable= true); + DiceAlias(const DiceAlias& alias); + /** + * @brief ~DiceAlias + */ + virtual ~DiceAlias(); + /** + * @brief resolved + * @param str + * @return + */ + bool resolved(QString& str); + /** + * @brief setCommand + * @param key + */ + void setPattern(const QString& pattern); + /** + * @brief setValue + * @param value + */ + void setCommand(QString command); + /** + * @brief setType + */ + void setType(RESOLUTION_TYPE); + + /** + * @brief getCommand + * @return + */ + QString pattern() const; + /** + * @brief getValue + * @return + */ + QString command() const; + /** + * @brief isReplace + * @return + */ + bool isReplace() const; + /** + * @brief setReplace + */ + void setReplace(bool); + + /** + * @brief isEnable + * @return + */ + bool isEnable() const; + /** + * @brief setEnable + * @param b + */ + void setEnable(bool b); + /** + * @brief getComment + * @return + */ + QString comment() const; + /** + * @brief setComment + * @param comment + */ + void setComment(const QString& comment); + +private: + QString m_pattern; + QString m_command; + QString m_comment; + RESOLUTION_TYPE m_type; + bool m_isEnable; +}; + +#endif // DICEALIAS_H diff --git a/src/libparser/include/diceparser/diceparser.h b/src/libparser/include/diceparser/diceparser.h new file mode 100644 index 0000000..bf2d570 --- /dev/null +++ b/src/libparser/include/diceparser/diceparser.h @@ -0,0 +1,130 @@ +/*************************************************************************** + * Copyright (C) 2014 by Renaud Guezennec * + * https://rolisteam.org/contact * + * * + * This file is part of DiceParser * + * * + * DiceParser is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ +#ifndef DICEPARSER_H +#define DICEPARSER_H + +#include <QJsonObject> +#include <QMap> +#include <QString> +#include <QVariant> +#include <memory> +#include <vector> + +#include <diceparser/diceparser_global.h> + +#include <diceparser/diceparserhelper.h> +#include <diceparser/highlightdice.h> + +class ExplodeDiceNode; +class ParsingToolBox; +class DiceRollerNode; +class DiceAlias; +class ExecutionNode; +/** + * @page DiceParser Dice Parser + * + * @section Intro Introduction + * Diceparser is the software component dedicated to compute dice command in rolisteam.<br/> + * + * @section grammar The Grammar + * + * The grammar is described in Readme.md + */ + +/** + * @brief The DiceParser class facade class, it receives a command and return a DiceResult class (not yet implemented). + */ +class DICEPARSER_EXPORT DiceParser +{ +public: + /** + * @brief DiceParser default constructor + */ + DiceParser(); + /** + * @brief ~DiceParser + */ + virtual ~DiceParser(); + + // Command process methods + /** + * @brief parseLine, method to call for starting the dice roll. It will parse the command and run the execution + * tree. + * @param str dice command + * @return bool every thing is fine or not + */ + bool parseLine(QString str, bool allowAlias= true); + void start(); + void cleanAll(); + + // debug + void writeDownDotTree(QString filepath); + + // control methods + bool hasIntegerResultNotInFirst() const; + bool hasDiceResult() const; + bool hasStringResult() const; + bool hasSeparator() const; + + // alias management + const QList<DiceAlias*>& constAliases() const; + QList<DiceAlias*>* aliases() const; + void cleanAliases(); + void insertAlias(DiceAlias*, int); + QString convertAlias(const QString& cmd) const; + + QStringList allFirstResultAsString(bool& hasAlias); + QStringList getAllDiceResult(bool& hasAlias); + + // Accessors + int startNodeCount() const; + QList<qreal> scalarResultsFromEachInstruction() const; + QStringList stringResultFromEachInstruction(bool& hasAlias) const; + void diceResultFromEachInstruction(QList<ExportedDiceResult>& resultList) const; + QString finalStringResult(std::function<QString(const QString&, const QString&, bool)> colorize) const; + + QString diceCommand() const; + QMap<Dice::ERROR_CODE, QString> errorMap() const; + QString comment() const; + QString humanReadableWarning() const; + QString humanReadableError() const; + QString resultAsJSon(std::function<QString(const QString&, const QString&, bool)> colorize, + bool removeUnhighligthed= false) const; + + // QStringList stringResult() const; + // QStringList allDiceResult(bool& hasAlias) const; + // void lastDiceResult(QList<ExportedDiceResult>& diceValues, bool& homogeneous) const; + + // setters + void setPathToHelp(QString l); + void setVariableDictionary(const QHash<QString, QString>& variables); + void setComment(const QString& comment); + +private: + bool readBlocInstruction(QString& str, ExecutionNode*& resultnode); + +private: + std::unique_ptr<ParsingToolBox> m_parsingToolbox; + QString m_command; +}; + +#endif // DICEPARSER_H diff --git a/src/libparser/include/diceparser/diceparser_global.h b/src/libparser/include/diceparser/diceparser_global.h new file mode 100644 index 0000000..47829cc --- /dev/null +++ b/src/libparser/include/diceparser/diceparser_global.h @@ -0,0 +1,11 @@ +#ifndef DICEPARSER_GLOBAL_H +#define DICEPARSER_GLOBAL_H + +#include <QtCore/qglobal.h> + +#if defined(DICEPARSER_LIBRARY) +#define DICEPARSER_EXPORT Q_DECL_EXPORT +#else +#define DICEPARSER_EXPORT Q_DECL_IMPORT +#endif +#endif // DICEPARSER_GLOBAL_H diff --git a/src/libparser/include/diceparser/diceparserhelper.h b/src/libparser/include/diceparser/diceparserhelper.h new file mode 100644 index 0000000..6190df2 --- /dev/null +++ b/src/libparser/include/diceparser/diceparserhelper.h @@ -0,0 +1,96 @@ +#ifndef DICEPARSERHELPER_H +#define DICEPARSERHELPER_H + +class ValidatorList; +class ExecutionNode; + +#include <diceparser/diceparser_global.h> + +namespace Dice +{ +enum class CONDITION_STATE : int +{ + ERROR_STATE, + ALWAYSTRUE, + UNREACHABLE, + REACHABLE +}; + +enum class ERROR_CODE : int +{ + NO_DICE_ERROR, + DIE_RESULT_EXPECTED, + BAD_SYNTAXE, + ENDLESS_LOOP_ERROR, + DIVIDE_BY_ZERO, + NOTHING_UNDERSTOOD, + NO_DICE_TO_ROLL, + TOO_MANY_DICE, + NO_VARIBALE, + INVALID_INDEX, + UNEXPECTED_CHARACTER, + NO_PREVIOUS_ERROR, + NO_VALID_RESULT, + SCALAR_RESULT_EXPECTED +}; + +/** + * @brief The RESULT_TYPE enum or combinaison + */ +enum class RESULT_TYPE : int +{ + NONE= 0, + SCALAR= 1, + STRING= 2, + DICE_LIST= 4 +}; +/** + * @brief The ConditionType enum defines compare method + */ +enum ConditionType +{ + OnEach, + OnEachValue, + OneOfThem, + AllOfThem, + OnScalar +}; + +enum class CompareOperator +{ + Equal, + GreaterThan, + LesserThan, + GreaterOrEqual, + LesserOrEqual, + Different +}; +enum class ArithmeticOperator +{ + PLUS, + MINUS, + DIVIDE, + MULTIPLICATION, + INTEGER_DIVIDE, + POW +}; +enum class LogicOperation +{ + OR, + EXCLUSIVE_OR, + AND, + NONE +}; + +enum class ConditionOperator +{ + Modulo +}; + +struct DICEPARSER_EXPORT CaseInfo +{ + ValidatorList* validatorList; + ExecutionNode* node; +}; +} // namespace Dice +#endif // DICEPARSERHELPER_H diff --git a/src/libparser/include/diceparser/highlightdice.h b/src/libparser/include/diceparser/highlightdice.h new file mode 100644 index 0000000..a3928a1 --- /dev/null +++ b/src/libparser/include/diceparser/highlightdice.h @@ -0,0 +1,68 @@ +/*************************************************************************** + * Copyright (C) 2016 by Renaud Guezennec * + * http:://www.rolisteam.org/contact * + * * + * rolisteam is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ +#ifndef HighLightDice_H +#define HighLightDice_H + +#include <QList> +#include <QMap> +#include <QString> + +#include <diceparser/diceparser_global.h> + +class DICEPARSER_EXPORT HighLightDice +{ +public: + HighLightDice(QList<qint64> result, bool isHighlighted, QString color, bool displayed, quint64 faces, + const QString& uuid); + virtual ~HighLightDice(); + + QList<qint64> result() const; + void setResult(const QList<qint64>& result); + + bool isHighlighted() const; + void setHighlight(bool hasHighlight); + + QString color() const; + void setColor(const QString& color); + + bool displayed() const; + void setDisplayed(bool displayed); + + quint64 faces() const; + void setFaces(const quint64& faces); + + QString getResultString() const; + + QString uuid() const; + void setUuid(const QString& uuid); + +private: + QList<qint64> m_result; + bool m_hasHighlight= true; + QString m_color; + bool m_displayed= false; + quint64 m_faces; + QString m_uuid; +}; + +typedef QList<HighLightDice> ListDiceResult; +typedef QMap<quint64, QList<ListDiceResult>> ExportedDiceResult; + +#endif // HighLightDice_H diff --git a/src/libparser/include/diceparser/parsingtoolbox.h b/src/libparser/include/diceparser/parsingtoolbox.h new file mode 100644 index 0000000..69f433a --- /dev/null +++ b/src/libparser/include/diceparser/parsingtoolbox.h @@ -0,0 +1,284 @@ +/*************************************************************************** + * Copyright (C) 2014 by Renaud Guezennec * + * https://rolisteam.org/contact * + * * + * This file is part of DiceParser * + * * + * DiceParser is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ +#ifndef PARSINGTOOLBOX_H +#define PARSINGTOOLBOX_H + +#include <QJsonArray> +#include <QJsonDocument> +#include <QJsonObject> +#include <QMap> +#include <QVariant> +#include <functional> +#include <vector> + +#include "diceparserhelper.h" +#include "highlightdice.h" +//#include "dicerollernode.h" +//#include "executionnode.h" +//#include "node/ifnode.h" +//#include "node/paintnode.h" +//#include "node/scalaroperatornode.h" +//#include "operationcondition.h" +//#include "range.h" +//#include "validatorlist.h" + +#include <diceparser/diceparser_global.h> +class Range; +class RepeaterNode; +class DiceAlias; +class ExplodeDiceNode; +class SwitchCaseNode; +class ReplaceValueNode; +class PainterNode; +class ValidatorList; +class Validator; +class DiceRollerNode; +class ExecutionNode; +class DICEPARSER_EXPORT SubtituteInfo +{ +public: + SubtituteInfo(); + + bool isValid() const; + + int length() const; + void setLength(int length); + + int resultIndex() const; + void setResultIndex(int valueIndex); + + int position() const; + void setPosition(int position); + + int digitNumber() const; + void setDigitNumber(int digitNumber); + + int subIndex() const; + void setSubIndex(int subindex); + +private: + int m_length= 2; + int m_digitNumber= 0; + int m_resultIndex= -1; + int m_position= -1; + int m_subIndex= -1; +}; + +/** + * @brief The ParsingToolBox is gathering many useful methods for dice parsing. + * Its goal is to make the diceparser a bit lighter. + */ +class DICEPARSER_EXPORT ParsingToolBox +{ +public: + enum LIST_OPERATOR + { + NONE= 0x00, + UNIQUE= 0x01, + NOCOMMA= 0x02, + UniqueAndNoComma= 0x03 + }; + + enum Function + { + REPEAT + }; + enum OptionOperator + { + KeepAndExplode, // K + Keep, // k + Reroll, // r + RerollUntil, // R + Explode, // e + Sort, // s + Count, // c + RerollAndAdd, // a + Merge, // m + ifOperator, // i + Painter, // p + Filter, // f + Split, // y + Group, // g + Occurences, // o + Unique, // u + Bind, // b + AllSameExplode, // t + SwitchCaseOption, // S + TransformOption // T + }; + enum DiceOperator + { + D, + L + }; + enum NodeAction + { + JumpBackward + }; + ParsingToolBox(); + ParsingToolBox(const ParsingToolBox& data); + virtual ~ParsingToolBox(); + void clearUp(); + + // Build execution tree + DiceRollerNode* getDiceRollerNode(ExecutionNode* previous); + DiceRollerNode* addRollDiceNode(qint64 faces, ExecutionNode*); + ExplodeDiceNode* addExplodeDiceNode(qint64 faces, ExecutionNode* previous); + Dice::CONDITION_STATE isValidValidator(ExecutionNode* previous, ValidatorList* val); + ExecutionNode* addSort(ExecutionNode* e, bool b); + + // parsing tools + static bool readAscending(QString& str); + static bool readStopAtFirst(QString& str); + bool readLogicOperator(QString& str, Dice::CompareOperator& op); + Validator* readValidator(QString& str, bool hasSquare= false); + ValidatorList* readValidatorList(QString& str); + static bool readNumber(QString& str, qint64& myNumber); + static bool readString(QString& str, QString& strresult); + static bool readVariable(QString& str, qint64& myNumber, QString& reasonFail); + static bool readOpenParentheses(QString& str); + static bool readCloseParentheses(QString& str); + + static bool readDynamicVariable(QString& str, qint64& index); + bool readList(QString& str, QStringList& list, QList<Range>& ranges); + bool readDiceRange(QString& str, qint64& start, qint64& end); + static LIST_OPERATOR readListOperator(QString& str); + void readProbability(QStringList& str, QList<Range>& ranges); + bool readLogicOperation(QString& str, Dice::LogicOperation& op); + bool readDiceLogicOperator(QString& str, Dice::ConditionOperator& op); + bool readArithmeticOperator(QString& str, Dice::ArithmeticOperator& op); + std::vector<ExecutionNode*> readInstructionList(QString& str, bool startNode); + static Dice::ConditionType readConditionType(QString& str); + bool readComment(QString& str, QString&, QString&); + bool readOperand(QString& str, ExecutionNode*& node); + static int findClosingCharacterIndexOf(QChar open, QChar closing, const QString& str, int offset); + static void readSubtitutionParameters(SubtituteInfo& info, QString& rest); + static bool readPainterParameter(PainterNode* painter, QString& str); + static bool readComma(QString& str); + bool readReaperArguments(RepeaterNode* node, QString& source); + bool readExpression(QString& str, ExecutionNode*& node); + bool readInstructionOperator(QChar c); + bool readNode(QString& str, ExecutionNode*& node); + /** + * @brief readIfInstruction reads the current command to build if node with proper parameters. + * @param str is the command string, if IF istruction is found, the str will be changed, in other case the string is + * unmodified + * @param trueNode is the branch's beginning to be executed if the IfNode is true. + * @param falseNode is the branch's beginning to be executed if the IfNode is false. + * @return true, ifNode has been found, false otherwise + */ + bool readIfInstruction(QString& str, ExecutionNode*& trueNode, ExecutionNode*& falseNode); + bool readOptionFromNull(QString& str, ExecutionNode*& node); + bool readOperatorFromNull(QString& str, ExecutionNode*& node); + bool readParameterNode(QString& str, ExecutionNode*& node); + bool readFunction(QString& str, ExecutionNode*& node); + bool readDice(QString& str, ExecutionNode*& node); + bool readDiceOperator(QString&, DiceOperator&); + bool readDiceExpression(QString&, ExecutionNode*& node); + bool readOperator(QString&, ExecutionNode* previous); + bool readCommand(QString& str, ExecutionNode*& node); + bool readBlocInstruction(QString& str, ExecutionNode*& resultnode); + bool readOption(QString&, ExecutionNode* node); // OptionOperator& option, + bool readValuesList(QString& str, ExecutionNode*& node); + bool readSwitchCaseNode(QString& str, SwitchCaseNode* node); + bool readReplaceValueNode(QString& str, ReplaceValueNode* node); + + // Error + bool hasError() const; + void addError(Dice::ERROR_CODE code, const QString& msg); + void addWarning(Dice::ERROR_CODE code, const QString& msg); + const QMap<Dice::ERROR_CODE, QString>& getErrorList() const; + const QMap<Dice::ERROR_CODE, QString>& getWarningList() const; + + // Traversal functions + static QString number(qreal value); + static ExecutionNode* getLeafNode(ExecutionNode* start); + const std::vector<ExecutionNode*>& getStartNodes(); + static void setStartNodes(std::vector<ExecutionNode*>* startNodes); + std::pair<bool, QVariant> hasResultOfType(Dice::RESULT_TYPE, ExecutionNode* node, bool notthelast= false) const; + QList<qreal> scalarResultsFromEachInstruction() const; + std::pair<QString, QString> finalScalarResult() const; + QString finalStringResult(std::function<QString(const QString&, const QString&, bool)> colorize, + bool removeUnhighlighted= false) const; + QStringList allFirstResultAsString(bool& hasAlias) const; + QList<qreal> sumOfDiceResult() const; + QList<ExportedDiceResult> diceResultFromEachInstruction() const; + bool hasIntegerResultNotInFirst() const; + bool hasDiceResult() const; + bool hasStringResult() const; + + // result + static QString replaceVariableToValue(const QString& source, QStringList values, + QMap<Dice::ERROR_CODE, QString>& errorMap); + static QString replacePlaceHolderToValue(const QString& source, const QList<ExportedDiceResult>& list, + bool removeUnhighlighted, + std::function<QString(const QString&, const QString&, bool)> colorize); + static SubtituteInfo readVariableFromString(const QString& source, int& start); + static SubtituteInfo readPlaceHolderFromString(const QString& source, int& start); + static ExportedDiceResult finalDiceResultFromInstruction(ExecutionNode* start); + static ExportedDiceResult allDiceResultFromInstruction(ExecutionNode* start); + void addResultInJson(QJsonObject& obj, Dice::RESULT_TYPE type, const QString& key, ExecutionNode* start, bool b); + void addDiceResultInJson(QJsonObject& obj, ExecutionNode* start, + std::function<QString(const QString&, const QString&, bool)> colorize); + + // accessors + void setComment(const QString& comment); + QString getComment() const; + void setHelpPath(const QString& path); + static QHash<QString, QString> getVariableHash(); + static void setVariableHash(const QHash<QString, QString>& variableHash); + void setStartNodes(std::vector<ExecutionNode*> nodes); + + // Aliases + QString convertAlias(QString str); + void insertAlias(DiceAlias* dice, int i); + const QList<DiceAlias*>& getAliases() const; + QList<DiceAlias*>* aliases(); + void setAliases(const QList<DiceAlias*> list); + void cleanUpAliases(); + + static bool readStringResultParameter(QString& str); + static QString replacePlaceHolderFromJson(const QString& source, const QJsonObject& obj); + +private: + QMap<QString, Dice::CompareOperator> m_logicOp; + QMap<QString, Dice::LogicOperation> m_logicOperation; + QMap<QString, Dice::ConditionOperator> m_conditionOperation; + std::vector<std::pair<QString, Dice::ArithmeticOperator>> m_arithmeticOperation; + QMap<QString, DiceOperator> m_mapDiceOp; + QMap<QString, OptionOperator> m_OptionOp; + QMap<QString, NodeAction> m_nodeActionMap; + std::map<QString, Function> m_functionMap; + QStringList m_commandList; + + QMap<Dice::ERROR_CODE, QString> m_errorMap; + QMap<Dice::ERROR_CODE, QString> m_warningMap; + std::vector<ExecutionNode*> m_startNodes; + + QString m_comment; + + static QHash<QString, QString> m_variableHash; + QString m_helpPath; + QList<DiceAlias*> m_aliasList; +}; + +#endif // PARSINGTOOLBOX_H |