Merge branch 'liberation' into 'master'

Add fuzzer on the DiceParser

See merge request kde/rolisteam-diceparser!2

1 files changed, 357 insertions, 0 deletions

diff --git a/include/diceparser.h b/include/diceparser.h
new file mode 100644
index 0000000..32694a3
--- /dev/null
+++ b/include/diceparser.h
@@ -0,0 +1,357 @@
+/***************************************************************************
+ * Copyright (C) 2014 by Renaud Guezennec                                   *
+ * http://www.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 <QMap>
+#include <QString>
+#include <vector>
+
+#include "highlightdice.h"
+#include "diceparserhelper.h"
+//#include "node/executionnode.h"
+
+typedef QList<HighLightDice> ListDiceResult;
+typedef QMap<quint64, ListDiceResult> ExportedDiceResult;
+
+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
+{
+public:
+    /**
+     * @brief The DiceOperator enum gathering all dice operators
+     */
+    enum DiceOperator
+    {
+        D,
+        L
+    };
+    /**
+     * @brief The DiceSymbol enum
+     */
+    enum NodeAction
+    {
+        JumpBackward
+    };
+    /**
+     * @brief The OptionOperator enum gathering all options  availables for result.
+     */
+    enum OptionOperator
+    {
+        KeepAndExplode,
+        Keep,
+        Reroll,
+        RerollUntil,
+        Explode,
+        Sort,
+        Count,
+        RerollAndAdd,
+        Merge,
+        ifOperator,
+        Painter,
+        Filter,
+        Split,
+        Group,
+        Occurences,
+        Unique,
+        Bind
+    };
+    /**
+     * @brief The CommandOperator enum
+     */
+    enum CommandOperator
+    {
+    };
+
+    /**
+     * @brief DiceParser default constructor
+     */
+    DiceParser();
+    /**
+     * @brief ~DiceParser
+     */
+    virtual ~DiceParser();
+
+    /**
+     * @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);
+    /**
+     * @brief getStartNodeCount
+     * @return
+     */
+    int getStartNodeCount() const;
+    /**
+     * @brief Start running the execution tree
+     *
+     */
+    void start();
+    /**
+     * @brief displayDotTree - Write the execution tree into file using dot format.
+     * @param filepath absolute or relative path to the tree file.
+     */
+    void writeDownDotTree(QString filepath);
+    /**
+     * @brief getLastIntegerResults
+     * @return
+     */
+    QList<qreal> getLastIntegerResults();
+    /**
+     * @brief getSumOfDiceResult
+     * @return
+     */
+    QList<qreal> getSumOfDiceResult();
+    /**
+     * @brief getLastDiceResult
+     * @return
+     */
+    void getLastDiceResult(QList<ExportedDiceResult>& diceValues, bool& homogeneous);
+    /**
+     * @brief hasIntegerResultNotInFirst
+     * @return
+     */
+    bool hasIntegerResultNotInFirst();
+    /**
+     * @brief hasDiceResult
+     * @return
+     */
+    bool hasDiceResult();
+    /**
+     * @brief getDiceCommand
+     * @return
+     */
+    QString getDiceCommand() const;
+    /**
+     * @brief hasStringResult
+     * @return
+     */
+    bool hasStringResult();
+    /**
+     * @brief getStringResult
+     * @return
+     */
+    QStringList getStringResult();
+    /**
+     * @brief humanReadableError
+     * @return
+     */
+    QString humanReadableError();
+    /**
+     * @brief getAliases
+     * @return
+     */
+    QList<DiceAlias*>* getAliases();
+    /**
+     * @brief insertAlias
+     */
+    void insertAlias(DiceAlias*, int);
+    /**
+     * @brief DiceParser::convertAlias
+     * @param str
+     * @return
+     */
+    QString convertAlias(QString str);
+    /**
+     * @brief getErrorList
+     * @return
+     */
+    QMap<Dice::ERROR_CODE, QString> getErrorMap();
+    /**
+     * @brief setPathToHelp set the path to the documentation, this path must be adatped to the lang of application etc…
+     * @param l the path.
+     */
+    void setPathToHelp(QString l);
+    /**
+     * @brief getAllStringResult
+     * @return
+     */
+    QStringList getAllStringResult(bool& hasAlias);
+    /**
+     * @brief getAllDiceResult
+     * @param hasAlias
+     * @return
+     */
+    QStringList getAllDiceResult(bool& hasAlias);
+    /**
+     * @brief hasSeparator allows to know if the current command has separator.
+     * @return true when the command has separator, false otherwise.
+     */
+    bool hasSeparator() const;
+
+    /**
+     * @brief setVariableDictionary
+     * @param variables
+     */
+    void setVariableDictionary(const QHash<QString, QString>& variables);
+    QString getComment() const;
+    void setComment(const QString& comment);
+
+    void getDiceResultFromAllInstruction(QList<ExportedDiceResult>& resultList);
+    QString humanReadableWarning();
+
+    bool readValuesList(QString& str, ExecutionNode*& node);
+    void cleanAll();
+private:
+    /**
+     * @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 readInstructionList(QString& str);
+    bool readOptionFromNull(QString& str, ExecutionNode*& node);
+    bool readOperatorFromNull(QString& str, ExecutionNode*& node);
+    bool readParameterNode(QString& str, ExecutionNode*& node);
+    /**
+     * @brief readExpression
+     * @param str
+     * @param node
+     * @return
+     */
+    bool readExpression(QString& str, ExecutionNode*& node);
+    /**
+     * @brief readDice
+     * @param str
+     * @return
+     */
+    bool readDice(QString& str, ExecutionNode*& node);
+    /**
+     * @brief readDiceOperator
+     * @return
+     */
+    bool readDiceOperator(QString&, DiceOperator&);
+    /**
+     * @brief readDiceExpression
+     * @param node
+     * @return
+     */
+    bool readDiceExpression(QString&, ExecutionNode*& node);
+    /**
+     * @brief readOperator
+     * @return
+     */
+    bool readOperator(QString&, ExecutionNode* previous);
+    /**
+     * @brief DiceParser::readCommand
+     * @param str
+     * @param node
+     * @return
+     */
+    bool readCommand(QString& str, ExecutionNode*& node);
+
+    /**
+     * @brief readOption
+     */
+    bool readOption(QString&, ExecutionNode* node); // OptionOperator& option,
+
+    /**
+     * @brief addRollDiceNode
+     * @param faces
+     * @return
+     */
+    DiceRollerNode* addRollDiceNode(qint64 faces, ExecutionNode*);
+    /**
+     * @brief addExplodeDiceNode
+     * @param faces
+     * @param previous
+     * @return
+     */
+    ExplodeDiceNode* addExplodeDiceNode(qint64 faces, ExecutionNode* previous);
+    /**
+     * @brief readOperand
+     * @param node
+     * @return
+     */
+    bool readOperand(QString&, ExecutionNode*& node);
+
+    /**
+     * @brief readInstructionOperator
+     * @param c
+     * @return
+     */
+    bool readInstructionOperator(QChar c);
+    /**
+     * @brief readNode
+     * @param str
+     * @param node
+     * @return
+     */
+    bool readNode(QString& str, ExecutionNode*& node);
+
+    /**
+     * @brief getLeafNode
+     * @return
+     */
+    ExecutionNode* getLeafNode(ExecutionNode* node);
+
+    /**
+     * @brief hasResultOfType
+     * @param notthelast
+     * @return
+     */
+    bool hasResultOfType(Dice::RESULT_TYPE, ExecutionNode* node, bool notthelast= false);
+    bool readBlocInstruction(QString& str, ExecutionNode*& resultnode);
+
+private:
+    QMap<QString, DiceOperator>* m_mapDiceOp;
+    QMap<QString, OptionOperator>* m_OptionOp;
+    QMap<QString, NodeAction>* m_nodeActionMap;
+    QList<DiceAlias*>* m_aliasList;
+    QStringList* m_commandList;
+
+    QMap<Dice::ERROR_CODE, QString> m_errorMap;
+    QMap<Dice::ERROR_CODE, QString> m_warningMap;
+
+    ExecutionNode* m_start= nullptr;
+    std::vector<ExecutionNode*> m_startNodes;
+    QString m_command;
+    ParsingToolBox* m_parsingToolbox;
+    QString m_helpPath;
+    bool m_currentTreeHasSeparator;
+    QString m_comment;
+};
+
+#endif // DICEPARSER_H