Possibilité de verifier plusieurs valeurs dans un seul 'quand'.

Author: Program132

src/Parser.cpp

@@ -33,6 +33,16 @@ namespace FPL {
         };
     }
 
+    bool ValueInSTRvector(std::vector<std::string>& array, std::string& value) {
+        for (auto e : array) {
+
+            if (e == value) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     void Parser::ManageVariableName(std::optional<FonctionDefinition>& fonction, std::string name) {
         if (isVariable(name)) {
             std::cerr << "Veuillez choisir un autre nom pour votre variable." << std::endl;
@@ -200,6 +210,8 @@ namespace FPL {
             if (CheckerOperateur("{").has_value()) {
                 while (!CheckerOperateur("}").has_value()) {
                     std::vector<std::string> contentChecking;
+                    std::vector<std::string> contentValues;
+                    bool morethanoneValue = false;
 
                     auto checkerInstruction = CheckerIdentifiant();
                     if (!checkerInstruction.has_value() && CheckerOperateur("}").has_value()) {
@@ -211,11 +223,48 @@ namespace FPL {
 
                     auto wantCheckValue = CheckerValue();
                     if (!wantCheckValue.has_value()) {
-                        std::cerr << "Vous devez une valeur que vous souhaitez verifier !" << std::endl;
+                        std::cerr << "Vous devez mettre une valeur que vous souhaitez verifier !" << std::endl;
                         exit(1);
                     }
 
-                    if (CheckerOperateur(":").has_value()) {
+                    if (CheckerOperateur(",").has_value()) {
+                        auto wantCheckValue2 = CheckerValue();
+                        if (wantCheckValue2.has_value()) {
+                            morethanoneValue = true;
+                            contentValues.push_back(wantCheckValue2->StatementName);
+                            contentValues.push_back(wantCheckValue->StatementName);
+
+                            while (!CheckerOperateur(":").has_value()) {
+                                auto nextValue = CheckerValue();
+                                if (!nextValue.has_value()) {
+                                    std::cerr << "Vous devez mettre une valeur que vous souhaitez verifier !" << std::endl;
+                                    exit(1);
+                                }
+
+                                contentValues.push_back(nextValue->StatementName);
+
+                                if (!CheckerOperateur(",").has_value()) {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    if (!morethanoneValue) {
+                        if (CheckerOperateur(":").has_value()) {
+                            while (!CheckerOperateur(",").has_value()) {
+                                if (mCurrentToken->mType == CHAINE_LITERAL) {
+                                    mCurrentToken->mText += "\"";
+                                }
+
+                                contentChecking.push_back(mCurrentToken->mText);
+                                ++mCurrentToken;
+                            }
+                        } else {
+                            std::cerr << "Vous devez mettre le symbole ':' pour mettre votre code." << std::endl;
+                            exit(1);
+                        }
+                    } else {
                         while (!CheckerOperateur(",").has_value()) {
                             if (mCurrentToken->mType == CHAINE_LITERAL) {
                                 mCurrentToken->mText += "\"";
@@ -224,9 +273,6 @@ namespace FPL {
                             contentChecking.push_back(mCurrentToken->mText);
                             ++mCurrentToken;
                         }
-                    } else {
-                        std::cerr << "Vous devez mettre le symbole ':' pour mettre votre code." << std::endl;
-                        exit(1);
                     }
 
                     std::string finalContent;
@@ -246,21 +292,36 @@ namespace FPL {
 
                     if (fonction.has_value() && isArgument(fonction->FonctionName, PossibleVar->mText)) {
                         auto argument = mArguments[fonction->FonctionName][PossibleVar->mText];
-                        if (argument.ArgValue == wantCheckValue->StatementName) {
-                            parse(tokens, f);
-                            mCurrentToken = oldCurrentToken;
-                            didNotExecuteTheCodeWithif = true;
+                        if (!morethanoneValue) {
+                            if (argument.ArgValue == wantCheckValue->StatementName) {
+                                parse(tokens, f);
+                                mCurrentToken = oldCurrentToken;
+                                didNotExecuteTheCodeWithif = true;
+                            }
+                        } else {
+                            if (ValueInSTRvector(contentValues, argument.ArgValue)) {
+                                parse(tokens, f);
+                                mCurrentToken = oldCurrentToken;
+                                didNotExecuteTheCodeWithif = true;
+                            }
                         }
                     } else if (isVariable(PossibleVar->mText)) {
                         auto variable = mVariables[PossibleVar->mText];
-                        if (variable.VariableValue == wantCheckValue->StatementName) {
-                            parse(tokens, f);
-                            mCurrentToken = oldCurrentToken;
-                            didNotExecuteTheCodeWithif = true;
+                        if (!morethanoneValue) {
+                            if (variable.VariableValue == wantCheckValue->StatementName) {
+                                parse(tokens, f);
+                                mCurrentToken = oldCurrentToken;
+                                didNotExecuteTheCodeWithif = true;
+                            }
+                        } else {
+                            if (ValueInSTRvector(contentValues, variable.VariableValue)) {
+                                parse(tokens, f);
+                                mCurrentToken = oldCurrentToken;
+                                didNotExecuteTheCodeWithif = true;
+                            }
                         }
                     }
 
-
                     auto elseInstruction = CheckerIdentifiant();
                     if (elseInstruction.has_value() && elseInstruction->mText == "defaut") {
                         if (CheckerOperateur(":").has_value()) {