Management of string result inside string result.

4 files changed, 94 insertions, 44 deletions

diff --git a/cli/main.cpp b/cli/main.cpp
index 0b4b2bc..3de1d26 100644
--- a/cli/main.cpp
+++ b/cli/main.cpp
@@ -26,6 +26,7 @@
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
+#include <QRegularExpression>
 #include <QStringList>
 #include <QTextStream>
 
@@ -365,19 +366,28 @@ int startDiceParsing(QStringList& cmds, QString& treeFile, bool withColor, EXPOR
             if(parser.hasStringResult())
             {
                 bool ok;
-                QStringList allStringlist= parser.getAllStringResult(ok);
-                QString stringResult= allStringlist.join(" ; ");
+                QStringList allStringlist= parser.allFirstResultAsString(ok);
+
+                QStringList resultWithPlaceHolder;
+                std::for_each(allStringlist.begin(), allStringlist.end(), [&resultWithPlaceHolder](const QString& sub) {
+                    QRegularExpression ex("%[1-3]?|\\$[1-9]+|@[1-9]+");
+                    if(sub.contains(ex))
+                        resultWithPlaceHolder.append(sub);
+                });
+                auto stringResult
+                    = resultWithPlaceHolder.isEmpty() ? allStringlist.join(" ; ") : resultWithPlaceHolder.join(" ; ");
 
                 stringResult.replace("%1", scalarText);
                 stringResult.replace("%2", listOfDiceResult.join(",").trimmed());
                 stringResult.replace("%3", lastScalarText);
                 stringResult.replace("\\n", "\n");
 
-                // qDebug() << "before replace variable: " << lastScalarText << scalarText << listOfDiceResult
-                //        << listFull.size();
-                stringResult= ParsingToolBox::replaceVariableToValue(stringResult, strLst);
+                QMap<Dice::ERROR_CODE, QString> errorMap;
+                stringResult= ParsingToolBox::replaceVariableToValue(stringResult, allStringlist, errorMap);
                 stringResult= ParsingToolBox::replacePlaceHolderToValue(stringResult, listFull);
 
+                error= errorMap.values().join(", ");
+
                 int i= strLst.size();
                 for(auto it= strLst.rbegin(); it != strLst.rend(); ++it)
                 {
diff --git a/diceparser.cpp b/diceparser.cpp
index 9ef36a8..5c0590c 100644
--- a/diceparser.cpp
+++ b/diceparser.cpp
@@ -151,27 +151,22 @@ QStringList DiceParser::getStringResult()
     }
     return stringListResult;
 }
-QStringList DiceParser::getAllStringResult(bool& hasAlias)
+QStringList DiceParser::allFirstResultAsString(bool& hasAlias)
 {
     // QStringList allResult;
     QStringList stringListResult;
     for(auto node : m_parsingToolbox->getStartNodes())
     {
-        ExecutionNode* next= ParsingToolBox::getLeafNode(node);
-        Result* result= next->getResult();
-
-        while(nullptr != result)
+        QVariant var;
+        if(hasResultOfType(Dice::RESULT_TYPE::STRING, node, var))
         {
-            if(result->hasResultOfType(Dice::RESULT_TYPE::STRING))
-            {
-                StringResult* stringResult= dynamic_cast<StringResult*>(result);
-                if(nullptr != stringResult)
-                {
-                    stringListResult << stringResult->getText();
-                    hasAlias= stringResult->hasHighLight();
-                }
-            }
-            result= result->getPrevious();
+            stringListResult << var.toString();
+            hasAlias= true;
+        }
+        else if(hasResultOfType(Dice::RESULT_TYPE::SCALAR, node, var, true))
+        {
+            stringListResult << QString::number(var.toReal());
+            hasAlias= true;
         }
     }
     return stringListResult;
@@ -342,7 +337,8 @@ bool DiceParser::hasIntegerResultNotInFirst()
     bool result= false;
     for(auto node : m_parsingToolbox->getStartNodes())
     {
-        result|= hasResultOfType(Dice::RESULT_TYPE::SCALAR, node);
+        QVariant var;
+        result|= hasResultOfType(Dice::RESULT_TYPE::SCALAR, node, var, true);
     }
     return result;
 }
@@ -352,7 +348,8 @@ bool DiceParser::hasDiceResult()
     bool result= false;
     for(auto node : m_parsingToolbox->getStartNodes())
     {
-        result|= hasResultOfType(Dice::RESULT_TYPE::DICE_LIST, node);
+        QVariant var;
+        result|= hasResultOfType(Dice::RESULT_TYPE::DICE_LIST, node, var);
     }
     return result;
 }
@@ -361,11 +358,12 @@ bool DiceParser::hasStringResult()
     bool result= false;
     for(auto node : m_parsingToolbox->getStartNodes())
     {
-        result|= hasResultOfType(Dice::RESULT_TYPE::STRING, node);
+        QVariant var;
+        result|= hasResultOfType(Dice::RESULT_TYPE::STRING, node, var);
     }
     return result;
 }
-bool DiceParser::hasResultOfType(Dice::RESULT_TYPE type, ExecutionNode* node, bool notthelast)
+bool DiceParser::hasResultOfType(Dice::RESULT_TYPE type, ExecutionNode* node, QVariant& value, bool notthelast)
 {
     bool scalarDone= false;
     ExecutionNode* next= ParsingToolBox::getLeafNode(node);
@@ -374,11 +372,12 @@ bool DiceParser::hasResultOfType(Dice::RESULT_TYPE type, ExecutionNode* node, bo
     {
         bool lastResult= false;
         if(notthelast)
-            lastResult= (nullptr != result->getPrevious());
+            lastResult= (nullptr == result->getPrevious());
 
         if(result->hasResultOfType(type) && !lastResult)
         {
             scalarDone= true;
+            value= result->getResult(type);
         }
         result= result->getPrevious();
     }
@@ -428,7 +427,7 @@ void DiceParser::setComment(const QString& comment)
     m_parsingToolbox->setComment(comment);
 }
 
-QMap<Dice::ERROR_CODE, QString> DiceParser::getErrorMap()
+QMap<Dice::ERROR_CODE, QString> DiceParser::errorMap() const
 {
     QMap<Dice::ERROR_CODE, QString> map;
 
@@ -445,8 +444,8 @@ QMap<Dice::ERROR_CODE, QString> DiceParser::getErrorMap()
 }
 QString DiceParser::humanReadableError()
 {
-    auto errorMap= m_parsingToolbox->getErrorList();
-    QMapIterator<Dice::ERROR_CODE, QString> i(errorMap);
+    auto errorList= m_parsingToolbox->getErrorList();
+    QMapIterator<Dice::ERROR_CODE, QString> i(errorList);
     QString str("");
     while(i.hasNext())
     {
@@ -456,7 +455,7 @@ QString DiceParser::humanReadableError()
     }
 
     /// list
-    QMapIterator<Dice::ERROR_CODE, QString> j(getErrorMap());
+    QMapIterator<Dice::ERROR_CODE, QString> j(errorMap());
     while(j.hasNext())
     {
         j.next();
diff --git a/include/parsingtoolbox.h b/include/parsingtoolbox.h
index f3031f2..521c9cf 100644
--- a/include/parsingtoolbox.h
+++ b/include/parsingtoolbox.h
@@ -59,11 +59,15 @@ public:
     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;
 };
 
 /**
@@ -277,7 +281,8 @@ public:
     bool readOperand(QString& str, ExecutionNode*& node);
     static int findClosingCharacterIndexOf(QChar open, QChar closing, const QString& str, int offset);
 
-    static QString replaceVariableToValue(const QString& source, QStringList values);
+    static QString replaceVariableToValue(const QString& source, QStringList values,
+                                          QMap<Dice::ERROR_CODE, QString>& errorMap);
     static QString replacePlaceHolderToValue(const QString& source, const QList<ExportedDiceResult>& list);
 
     static SubtituteInfo readVariableFromString(const QString& source, int& start);
diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp
index e0b1df0..ffa5699 100644
--- a/parsingtoolbox.cpp
+++ b/parsingtoolbox.cpp
@@ -870,7 +870,8 @@ bool ParsingToolBox::readComment(QString& str, QString& result, QString& comment
     return false;
 }
 
-QString ParsingToolBox::replaceVariableToValue(const QString& source, QStringList values)
+QString ParsingToolBox::replaceVariableToValue(const QString& source, QStringList values,
+                                               QMap<Dice::ERROR_CODE, QString>& errorMap)
 {
     QString result= source;
 
@@ -879,23 +880,35 @@ QString ParsingToolBox::replaceVariableToValue(const QString& source, QStringLis
     do
     {
         auto ref= readVariableFromString(source, start);
-        if(ref.isValid())
+        if(ref.resultIndex() >= values.size())
         {
-            result.remove(ref.position(), ref.length());
-            auto val= values[ref.resultIndex() - 1];
-            if(ref.digitNumber() != 0)
-            {
-                auto realVal= QString("%1").arg(val, ref.digitNumber(), QChar('0'));
-                result.insert(ref.position(), realVal);
-            }
-            else
-            {
-                result.insert(ref.position(), val);
-            }
+            auto error= QString("No valid value at index: $%1").arg(ref.resultIndex());
+            errorMap.insert(Dice::ERROR_CODE::INVALID_INDEX, error);
+            return error;
+        }
+
+        valid= ref.isValid();
+        if(!valid)
+            continue;
+
+        result.remove(ref.position(), ref.length());
+        auto val= values[ref.resultIndex() - 1];
+
+        if(ref.subIndex() >= 0)
+        {
+            auto valSplit= val.split(",");
+            if(ref.subIndex() < valSplit.size())
+                val= valSplit[ref.subIndex()];
+        }
+
+        if(ref.digitNumber() != 0)
+        {
+            auto realVal= QString("%1").arg(val, ref.digitNumber(), QChar('0'));
+            result.insert(ref.position(), realVal);
         }
         else
         {
-            valid= false;
+            result.insert(ref.position(), val);
         }
     } while(valid);
 
@@ -979,6 +992,19 @@ void ParsingToolBox::readSubtitutionParameters(SubtituteInfo& info, QString& res
             }
         }
     }
+    if(rest.startsWith("["))
+    {
+        rest= rest.remove(0, 1);
+        qint64 number;
+        if(readNumber(rest, number))
+        {
+            if(rest.startsWith("]"))
+            {
+                rest= rest.remove(0, 1);
+                info.setSubIndex(static_cast<int>(number));
+            }
+        }
+    }
     info.setLength(info.length() + sizeS - rest.size());
 }
 
@@ -2030,3 +2056,13 @@ void SubtituteInfo::setDigitNumber(int digitNumber)
 {
     m_digitNumber= digitNumber;
 }
+
+int SubtituteInfo::subIndex() const
+{
+    return m_subIndex;
+}
+
+void SubtituteInfo::setSubIndex(int subindex)
+{
+    m_subIndex= subindex;
+}