changes

8 files changed, 156 insertions, 89 deletions

diff --git a/src/bin/cli/main.cpp b/src/bin/cli/main.cpp
index 9ec128a..2864c27 100644
--- a/src/bin/cli/main.cpp
+++ b/src/bin/cli/main.cpp
@@ -336,7 +336,8 @@ int startDiceParsing(QStringList& cmds, bool withColor, QString baseColor, EXPOR
                 allSameColor= true;
                 QString colorP;
                 json= parser.resultAsJSon(
-                    [&colorP, &allSameColor](const QString& value, const QString& color, bool) {
+                    [&colorP, &allSameColor](const QString& value, const QString& color, bool)
+                    {
                         if(colorP.isNull())
                             colorP= color;
                         else if(colorP != color)
@@ -348,25 +349,27 @@ int startDiceParsing(QStringList& cmds, bool withColor, QString baseColor, EXPOR
 
                 if(!allSameColor)
                 {
-                    json= parser.resultAsJSon([](const QString& value, const QString& color, bool highlight) {
-                        QString result= value;
-                        bool hasColor= !color.isEmpty();
-                        QString style;
-                        if(hasColor)
+                    json= parser.resultAsJSon(
+                        [](const QString& value, const QString& color, bool highlight)
                         {
-                            style+= QStringLiteral("fill=\"%1\" ").arg(color);
-                        }
-                        if(highlight)
-                        {
-                            if(style.isEmpty())
-                                style+= QStringLiteral("fill=\"%1\" ")
-                                            .arg("red"); // default color must get the value from the setting object
-                            style+= QStringLiteral("font-weight=\"bold\" ");
-                        }
-                        if(!style.isEmpty())
-                            result= QString("<tspan %2>%1</tspan>").arg(value).arg(style);
-                        return result;
-                    });
+                            QString result= value;
+                            bool hasColor= !color.isEmpty();
+                            QString style;
+                            if(hasColor)
+                            {
+                                style+= QStringLiteral("fill=\"%1\" ").arg(color);
+                            }
+                            if(highlight)
+                            {
+                                if(style.isEmpty())
+                                    style+= QStringLiteral("fill=\"%1\" ")
+                                                .arg("red"); // default color must get the value from the setting object
+                                style+= QStringLiteral("font-weight=\"bold\" ");
+                            }
+                            if(!style.isEmpty())
+                                result= QString("<tspan %2>%1</tspan>").arg(value).arg(style);
+                            return result;
+                        });
                 }
             }
             else if(TERMINAL == format)
@@ -374,7 +377,8 @@ int startDiceParsing(QStringList& cmds, bool withColor, QString baseColor, EXPOR
                 allSameColor= true;
                 QString colorP;
                 json= parser.resultAsJSon(
-                    [&colorP, &allSameColor, &baseColor](const QString& result, const QString& color, bool hightlight) {
+                    [&colorP, &allSameColor, &baseColor](const QString& result, const QString& color, bool hightlight)
+                    {
                         auto trueColor= color;
                         if(color.isEmpty())
                             trueColor= baseColor;
@@ -590,6 +594,12 @@ int main(int argc, char* argv[])
         cmd= "help";
     }
     QStringList cmdList= optionParser.positionalArguments();
+    for(auto& cmd : cmdList)
+        cmd= QUrl::fromPercentEncoding(cmd.toUtf8());
+
+    qDebug() << "cmdList" << cmdList;
+    // cmdList << "(1)-1d4e4mk00;300;[$1\u0004$3]k1;0100;200;300;[$1,$2,$3]k1TK\u0004;$1+$1;$2i:[<1]{1}{0}";
+    cmdList << "1d4e4mk00;300;100;[$1,$2,$3]k1TK\u0004";
 
     QJsonArray aliases;
     if(optionParser.isSet(alias))
diff --git a/src/libparser/CMakeLists.txt b/src/libparser/CMakeLists.txt
index 8793d45..80b9a25 100644
--- a/src/libparser/CMakeLists.txt
+++ b/src/libparser/CMakeLists.txt
@@ -5,6 +5,7 @@ set(QT_VERSION_MAJOR "6")
 find_package(Qt${QT_VERSION_MAJOR} ${QT_REQUIRED_VERSION} CONFIG REQUIRED COMPONENTS Core Test Gui Svg)
 find_package(Qt${QT_VERSION_MAJOR} ${QT_REQUIRED_VERSION} CONFIG COMPONENTS Qml Concurrent)
 
+option(STATIC_BUILD OFF)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} result node)
 
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
@@ -77,9 +78,17 @@ else()
 endif()
 
 IF(STATIC_BUILD)
-    set_target_properties(diceparser_static PROPERTIES OUTPUT_NAME diceparser CLEAN_DIRECT_OUTPUT 1)
     add_library(diceparser_static STATIC ${dice_sources} )
-    target_include_directories(diceparser_static PRIVATE include)
+    set_target_properties(diceparser_static PROPERTIES OUTPUT_NAME diceparser CLEAN_DIRECT_OUTPUT 1)
+    target_include_directories(diceparser_static
+      PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}
+        ${CMAKE_CURRENT_SOURCE_DIR}/include
+        ${CMAKE_CURRENT_SOURCE_DIR}/node
+        ${CMAKE_CURRENT_SOURCE_DIR}/result
+      PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
     target_link_libraries(diceparser_static PUBLIC Qt6::Core Qt6::Gui Qt6::Svg)
     if(${HAS_INSTALL})
       rinstallLib(diceparser_static libraries)
diff --git a/src/libparser/dicealias.cpp b/src/libparser/dicealias.cpp
index a5c079d..67e3046 100644
--- a/src/libparser/dicealias.cpp
+++ b/src/libparser/dicealias.cpp
@@ -117,7 +117,6 @@ QString makeReplament(const QString& pattern, const QString& command, QString cm
                 pos+= 1;
             }
 
-            // TODO to be replace by C++14 when it is ready
             for(auto i= patternPosList.rbegin(); i != patternPosList.rend(); ++i)
             {
                 cmd.replace(*i, 1, command);
diff --git a/src/libparser/diceparser.cpp b/src/libparser/diceparser.cpp
index 5ba8af1..43ee9ff 100644
--- a/src/libparser/diceparser.cpp
+++ b/src/libparser/diceparser.cpp
@@ -105,7 +105,7 @@ void DiceParser::start()
 {
     for(auto start : m_parsingToolbox->getStartNodes())
     {
-        start->run();
+        start->execute();
     }
 }
 
diff --git a/src/libparser/die.cpp b/src/libparser/die.cpp
index 4214b97..f752bbc 100644
--- a/src/libparser/die.cpp
+++ b/src/libparser/die.cpp
@@ -153,25 +153,25 @@ bool Die::hasChildrenValue()
 }
 void Die::replaceLastValue(qint64 value)
 {
-    m_rollResult.removeLast();
+    if(!m_rollResult.isEmpty())
+        m_rollResult.removeLast();
     insertRollValue(value);
 }
 
 void Die::roll(bool adding)
 {
-    if(m_maxValue != 0)
+    if(std::abs(m_base) >= std::abs(m_maxValue))
+        return;
+
+    std::uniform_int_distribution<qint64> dist(m_base, m_maxValue);
+    qint64 value= dist(s_rng);
+    if((adding) || (m_rollResult.isEmpty()))
     {
-        // quint64 value=(qrand()%m_faces)+m_base;
-        std::uniform_int_distribution<qint64> dist(m_base, m_maxValue);
-        qint64 value= dist(s_rng);
-        if((adding) || (m_rollResult.isEmpty()))
-        {
-            insertRollValue(value);
-        }
-        else
-        {
-            replaceLastValue(value);
-        }
+        insertRollValue(value);
+    }
+    else
+    {
+        replaceLastValue(value);
     }
 }
 
@@ -182,11 +182,9 @@ quint64 Die::getFaces() const
 qint64 Die::getLastRolledValue()
 {
     if(!m_rollResult.isEmpty())
-    {
         return m_rollResult.last();
-    }
-    else
-        return 0;
+
+    return 0;
 }
 bool Die::hasBeenDisplayed() const
 {
diff --git a/src/libparser/include/diceparser/diceparserhelper.h b/src/libparser/include/diceparser/diceparserhelper.h
index 6190df2..910b782 100644
--- a/src/libparser/include/diceparser/diceparserhelper.h
+++ b/src/libparser/include/diceparser/diceparserhelper.h
@@ -31,7 +31,9 @@ enum class ERROR_CODE : int
     UNEXPECTED_CHARACTER,
     NO_PREVIOUS_ERROR,
     NO_VALID_RESULT,
-    SCALAR_RESULT_EXPECTED
+    SCALAR_RESULT_EXPECTED,
+    NO_VALIDATOR_LIST,
+    NO_INTERNAL_INSTRUCTION
 };
 
 /**
diff --git a/src/libparser/include/diceparser/parsingtoolbox.h b/src/libparser/include/diceparser/parsingtoolbox.h
index 207b878..8cd9c25 100644
--- a/src/libparser/include/diceparser/parsingtoolbox.h
+++ b/src/libparser/include/diceparser/parsingtoolbox.h
@@ -132,7 +132,8 @@ public:
     void clearUp();
 
     // Build execution tree
-    DiceRollerNode* getDiceRollerNode(ExecutionNode* previous);
+    template <typename T>
+    T* getNode(ExecutionNode* previous);
     DiceRollerNode* addRollDiceNode(qint64 faces, ExecutionNode*);
     ExplodeDiceNode* addExplodeDiceNode(qint64 faces, ExecutionNode* previous);
     Dice::CONDITION_STATE isValidValidator(ExecutionNode* previous, ValidatorList* val);
@@ -222,7 +223,7 @@ public:
     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,
+                                             bool removeUnhighlighted, QList<std::pair<int, QStringList>> inst2Result,
                                              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);
diff --git a/src/libparser/parsingtoolbox.cpp b/src/libparser/parsingtoolbox.cpp
index 575b7b9..4d75ede 100644
--- a/src/libparser/parsingtoolbox.cpp
+++ b/src/libparser/parsingtoolbox.cpp
@@ -183,9 +183,9 @@ bool ParsingToolBox::readDiceLogicOperator(QString& str, Dice::ConditionOperator
 bool ParsingToolBox::readArithmeticOperator(QString& str, Dice::ArithmeticOperator& op)
 {
 
-    auto it= std::find_if(
-        m_arithmeticOperation.begin(), m_arithmeticOperation.end(),
-        [str](const std::pair<QString, Dice::ArithmeticOperator>& pair) { return str.startsWith(pair.first); });
+    auto it= std::find_if(m_arithmeticOperation.begin(), m_arithmeticOperation.end(),
+                          [str](const std::pair<QString, Dice::ArithmeticOperator>& pair)
+                          { return str.startsWith(pair.first); });
     if(it == m_arithmeticOperation.end())
         return false;
 
@@ -713,12 +713,21 @@ QString ParsingToolBox::finalStringResult(std::function<QString(const QString&,
     QStringList allStringlist= allFirstResultAsString(ok);
     auto listFull= diceResultFromEachInstruction();
 
+    QList<std::pair<int, QStringList>> placeHolderInfo;
     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);
-    });
+    int i= 0;
+    std::for_each(allStringlist.begin(), allStringlist.end(),
+                  [&resultWithPlaceHolder, &placeHolderInfo, &i](const QString& sub)
+                  {
+                      static QRegularExpression ex("%[1-3]?|\\$-?[1-9]+|@-?[1-9]+");
+                      if(sub.contains(ex))
+                      {
+                          resultWithPlaceHolder.append(sub);
+                          auto pair= std::make_pair(i, QStringList{sub});
+                          placeHolderInfo.append(pair);
+                      }
+                      ++i;
+                  });
     auto stringResult= resultWithPlaceHolder.isEmpty() ? allStringlist.join(",") : resultWithPlaceHolder.join(",");
 
     auto pairScalar= finalScalarResult();
@@ -730,8 +739,8 @@ QString ParsingToolBox::finalStringResult(std::function<QString(const QString&,
 
     QMap<Dice::ERROR_CODE, QString> errorMap;
     stringResult= ParsingToolBox::replaceVariableToValue(stringResult, allStringlist, errorMap);
-    stringResult= ParsingToolBox::replacePlaceHolderToValue(stringResult, listFull, removeUnhighlighted, colorize);
-
+    stringResult= ParsingToolBox::replacePlaceHolderToValue(stringResult, listFull, removeUnhighlighted,
+                                                            placeHolderInfo, colorize);
     return stringResult;
 }
 
@@ -924,17 +933,27 @@ bool ParsingToolBox::readStopAtFirst(QString& str)
 
 Dice::CONDITION_STATE ParsingToolBox::isValidValidator(ExecutionNode* previous, ValidatorList* val)
 {
-    DiceRollerNode* node= getDiceRollerNode(previous);
-    if(nullptr == node)
+    auto node= getNode<DiceRollerNode>(previous);
+    if(node)
+        return val->isValidRangeSize(node->getRange());
+
+    auto listNode= getNode<ValuesListNode>(previous);
+
+    if(!listNode)
         return Dice::CONDITION_STATE::ERROR_STATE;
 
-    return val->isValidRangeSize(node->getRange());
+    auto dice= dynamic_cast<DiceResult*>(listNode->getResult());
+    if(!dice)
+        return Dice::CONDITION_STATE::ERROR_STATE;
+
+    return Dice::CONDITION_STATE::REACHABLE;
 }
-DiceRollerNode* ParsingToolBox::getDiceRollerNode(ExecutionNode* previous)
+template <typename T>
+T* ParsingToolBox::getNode(ExecutionNode* previous)
 {
     while(nullptr != previous)
     {
-        DiceRollerNode* node= dynamic_cast<DiceRollerNode*>(previous);
+        auto node= dynamic_cast<T*>(previous);
         if(nullptr != node)
         {
             return node;
@@ -993,7 +1012,7 @@ ParsingToolBox::LIST_OPERATOR ParsingToolBox::readListOperator(QString& str)
     {
         auto keys= hash.keys();
         findOne= false;
-        for(auto const& key : qAsConst(keys))
+        for(auto const& key : std::as_const(keys))
         {
             if(str.startsWith(key))
             {
@@ -1209,13 +1228,13 @@ QString ParsingToolBox::replacePlaceHolderFromJson(const QString& source, const
     QStringList resultList;
     auto instructions= obj["instructions"].toArray();
     std::vector<std::vector<std::pair<int, QList<QStringList>>>> instructionResult;
-    for(auto inst : qAsConst(instructions))
+    for(auto inst : std::as_const(instructions))
     {
         std::vector<std::pair<int, QList<QStringList>>> map;
         auto obj= inst.toObject();
         auto vals= obj["diceval"].toArray();
         int lastFace= -1;
-        for(auto const& valRef : qAsConst(vals))
+        for(auto const& valRef : std::as_const(vals))
         {
             auto diceObj= valRef.toObject();
             auto face= diceObj["face"].toInt();
@@ -1239,7 +1258,8 @@ QString ParsingToolBox::replacePlaceHolderFromJson(const QString& source, const
         instructionResult.push_back(map);
     }
     std::transform(std::begin(instructionResult), std::end(instructionResult), std::back_inserter(resultList),
-                   [](const std::vector<std::pair<int, QList<QStringList>>>& map) {
+                   [](const std::vector<std::pair<int, QList<QStringList>>>& map)
+                   {
                        QStringList valuesStr;
                        auto multiKey= (map.size() > 1);
                        for(auto item : map)
@@ -1282,23 +1302,34 @@ QString ParsingToolBox::replacePlaceHolderFromJson(const QString& source, const
 
 QString ParsingToolBox::replacePlaceHolderToValue(const QString& source, const QList<ExportedDiceResult>& list,
                                                   bool removeUnhighlighted,
+                                                  QList<std::pair<int, QStringList>> inst2Result,
                                                   std::function<QString(const QString&, const QString&, bool)> colorize)
 {
+    // qDebug() << "replacePlaceHolderToValue:" << source;
+    /*for(auto& result : list)
+        for(auto [key, value] : result.asKeyValueRange())
+            for(auto const& resultList : value)
+                for(auto const& diceResult : resultList)
+                    qDebug() << "result:" << diceResult.getResultString() << diceResult.faces();*/
+
     QStringList resultList;
     std::transform(
         std::begin(list), std::end(list), std::back_inserter(resultList),
-        [removeUnhighlighted, colorize](const ExportedDiceResult& dice) {
+        [removeUnhighlighted, colorize](const ExportedDiceResult& dice)
+        {
             QStringList valuesStr;
             if(dice.size() == 1)
             {
                 auto values= dice.values();
                 std::transform(
                     std::begin(values), std::end(values), std::back_inserter(valuesStr),
-                    [removeUnhighlighted, colorize](const QList<ListDiceResult>& dice) {
+                    [removeUnhighlighted, colorize](const QList<ListDiceResult>& dice)
+                    {
                         QStringList textList;
                         std::transform(
                             std::begin(dice), std::end(dice), std::back_inserter(textList),
-                            [removeUnhighlighted, colorize](const ListDiceResult& dice) {
+                            [removeUnhighlighted, colorize](const ListDiceResult& dice)
+                            {
                                 QStringList list;
                                 ListDiceResult values= dice;
                                 if(removeUnhighlighted)
@@ -1309,9 +1340,8 @@ QString ParsingToolBox::replacePlaceHolderToValue(const QString& source, const Q
                                 }
 
                                 std::transform(std::begin(values), std::end(values), std::back_inserter(list),
-                                               [colorize](const HighLightDice& hl) {
-                                                   return colorize(hl.getResultString(), {}, hl.isHighlighted());
-                                               });
+                                               [colorize](const HighLightDice& hl)
+                                               { return colorize(hl.getResultString(), {}, hl.isHighlighted()); });
                                 return list.join(",");
                             });
                         textList.removeAll(QString());
@@ -1335,23 +1365,38 @@ QString ParsingToolBox::replacePlaceHolderToValue(const QString& source, const Q
             return valuesStr.join(",");
         });
 
-    QString result= source;
+    QString result;
     int start= source.size() - 1;
-    bool valid= true;
-    do
+    // qDebug() << "replacePlaceHolderToValue @@@:" << result << start << resultList << inst2Result;
+
+    for(auto const& pair : inst2Result)
     {
-        auto ref= readPlaceHolderFromString(source, start);
-        if(ref.isValid())
-        {
-            result.remove(ref.position(), ref.length());
-            auto val= resultList[ref.resultIndex() - 1];
-            result.insert(ref.position(), val);
-        }
-        else
+        auto instId= pair.first;
+        auto list= pair.second.join(",");
+        int start= list.size() - 1;
+        bool valid= true;
+        do
         {
-            valid= false;
-        }
-    } while(valid);
+            auto ref= readPlaceHolderFromString(list, start);
+
+            if(!ref.isValid())
+                break;
+
+            list.remove(ref.position(), ref.length());
+            auto index= ref.resultIndex() < 0 ? instId + ref.resultIndex() : ref.resultIndex() - 1;
+            qDebug() << "index: " << index << instId;
+            auto val= resultList[index - 1];
+            list.insert(ref.position(), val);
+            if(result.isEmpty())
+                result= list;
+            else
+                result= QStringList{result, list}.join(" ,");
+
+        } while(valid);
+    }
+
+    if(result.isEmpty())
+        return source;
 
     return result;
 }
@@ -1528,7 +1573,7 @@ bool ParsingToolBox::readValuesList(QString& str, ExecutionNode*& node)
     auto list= liststr.split(",");
     str= str.remove(0, pos + 1);
     auto values= new ValuesListNode();
-    for(auto var : qAsConst(list))
+    for(auto var : std::as_const(list))
     {
         qint64 number= 1;
         var= var.trimmed();
@@ -1644,11 +1689,14 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
                 {
                     auto validity= isValidValidator(previous, validatorList);
 
-                    FilterNode* filterNode= new FilterNode();
-                    filterNode->setValidatorList(validatorList);
+                    if(validity != Dice::CONDITION_STATE::ERROR_STATE)
+                    {
+                        FilterNode* filterNode= new FilterNode();
+                        filterNode->setValidatorList(validatorList);
 
-                    previous->setNextNode(filterNode);
-                    found= true;
+                        previous->setNextNode(filterNode);
+                        found= true;
+                    }
                 }
             }
             break;
@@ -2132,7 +2180,7 @@ bool ParsingToolBox::readDice(QString& str, ExecutionNode*& node)
 bool ParsingToolBox::readDiceOperator(QString& str, DiceOperator& op)
 {
     QStringList listKey= m_mapDiceOp.keys();
-    for(const QString& key : qAsConst(listKey))
+    for(const QString& key : std::as_const(listKey))
     {
         if(str.startsWith(key, Qt::CaseInsensitive))
         {