Fix #10412 FN useStlAlgorithm with iterators

cli/cmdlineparser.cpp

@@ -635,8 +635,8 @@ bool CmdLineParser::parseFromArgs(int argc, const char* const argv[])
                     for (const std::string &lib : mSettings->project.guiProject.libraries)
                         mSettings->libraries.emplace_back(lib);
 
-                    for (const std::string &ignorePath : mSettings->project.guiProject.excludedPaths)
-                        mIgnoredPaths.emplace_back(ignorePath);
+                    const auto& excludedPaths = mSettings->project.guiProject.excludedPaths;
+                    std::copy(excludedPaths.begin(), excludedPaths.end(), std::back_inserter(mIgnoredPaths));
 
                     const std::string platform(mSettings->project.guiProject.platform);
 

cli/cppcheckexecutor.cpp

@@ -51,6 +51,7 @@
 #include <sstream> // IWYU pragma: keep
 #include <utility>
 #include <vector>
+#include <numeric>
 
 #ifdef USE_UNIX_SIGNAL_HANDLING
 #include "cppcheckexecutorsig.h"
@@ -129,14 +130,10 @@ bool CppCheckExecutor::parseFromArgs(CppCheck *cppcheck, int argc, const char* c
     }
 
     // Output a warning for the user if he tries to exclude headers
-    bool warn = false;
     const std::vector<std::string>& ignored = parser.getIgnoredPaths();
-    for (const std::string &i : ignored) {
-        if (Path::isHeader(i)) {
-            warn = true;
-            break;
-        }
-    }
+    const bool warn = std::any_of(ignored.begin(), ignored.end(), [](const std::string& i) {
+        return Path::isHeader(i);
+    });
     if (warn) {
         std::cout << "cppcheck: filename exclusion does not apply to header (.h and .hpp) files." << std::endl;
         std::cout << "cppcheck: Please use --suppress for ignoring results from the header files." << std::endl;
@@ -154,11 +151,10 @@ bool CppCheckExecutor::parseFromArgs(CppCheck *cppcheck, int argc, const char* c
         // filter only for the selected filenames from all project files
         std::list<ImportProject::FileSettings> newList;
 
-        for (const ImportProject::FileSettings &fsetting : settings.project.fileSettings) {
-            if (matchglobs(mSettings->fileFilters, fsetting.filename)) {
-                newList.emplace_back(fsetting);
-            }
-        }
+        const std::list<ImportProject::FileSettings>& fileSettings = settings.project.fileSettings;
+        std::copy_if(fileSettings.begin(), fileSettings.end(), std::back_inserter(newList), [&](const ImportProject::FileSettings& fs) {
+            return matchglobs(mSettings->fileFilters, fs.filename);
+        });
         if (!newList.empty())
             settings.project.fileSettings = newList;
         else {
@@ -325,10 +321,9 @@ int CppCheckExecutor::check_internal(CppCheck& cppcheck)
         // Single process
         settings.jointSuppressionReport = true;
 
-        std::size_t totalfilesize = 0;
-        for (std::map<std::string, std::size_t>::const_iterator i = mFiles.begin(); i != mFiles.end(); ++i) {
-            totalfilesize += i->second;
-        }
+        const std::size_t totalfilesize = std::accumulate(mFiles.begin(), mFiles.end(), std::size_t(0), [](std::size_t v, const std::pair<std::string, std::size_t>& f) {
+            return v + f.second;
+        });
 
         std::size_t processedsize = 0;
         unsigned int c = 0;

cli/processexecutor.cpp

@@ -31,19 +31,20 @@
 #include "suppressions.h"
 
 #include <algorithm>
+#include <numeric>
 #include <cerrno>
 #include <csignal>
 #include <cstdlib>
 #include <cstring>
-#include <fcntl.h>
 #include <functional>
 #include <iostream>
 #include <list>
 #include <sstream> // IWYU pragma: keep
 #include <sys/select.h>
 #include <sys/wait.h>
 #include <unistd.h>
-#include <utility>
+#include <fcntl.h>
+
 
 #ifdef __SVR4  // Solaris
 #include <sys/loadavg.h>
@@ -217,10 +218,9 @@ unsigned int ProcessExecutor::check()
     unsigned int fileCount = 0;
     unsigned int result = 0;
 
-    std::size_t totalfilesize = 0;
-    for (std::map<std::string, std::size_t>::const_iterator i = mFiles.begin(); i != mFiles.end(); ++i) {
-        totalfilesize += i->second;
-    }
+    const std::size_t totalfilesize = std::accumulate(mFiles.begin(), mFiles.end(), std::size_t(0), [](std::size_t v, const std::pair<std::string, std::size_t>& p) {
+        return v + p.second;
+    });
 
     std::list<int> rpipes;
     std::map<pid_t, std::string> childFile;

cli/threadexecutor.cpp

@@ -49,15 +49,16 @@ class ThreadExecutor::SyncLogForwarder : public ErrorLogger
 {
 public:
     explicit SyncLogForwarder(ThreadExecutor &threadExecutor)
-        : mThreadExecutor(threadExecutor), mProcessedFiles(0), mTotalFiles(0), mProcessedSize(0), mTotalFileSize(0) {
+        : mThreadExecutor(threadExecutor), mProcessedFiles(0), mTotalFiles(0), mProcessedSize(0) {
 
-        mItNextFile = mThreadExecutor.mFiles.begin();
+        const std::map<std::string, std::size_t>& files = mThreadExecutor.mFiles;
+        mItNextFile = files.begin();
         mItNextFileSettings = mThreadExecutor.mSettings.project.fileSettings.begin();
 
-        mTotalFiles = mThreadExecutor.mFiles.size() + mThreadExecutor.mSettings.project.fileSettings.size();
-        for (std::map<std::string, std::size_t>::const_iterator i = mThreadExecutor.mFiles.begin(); i != mThreadExecutor.mFiles.end(); ++i) {
-            mTotalFileSize += i->second;
-        }
+        mTotalFiles = files.size() + mThreadExecutor.mSettings.project.fileSettings.size();
+        mTotalFileSize = std::accumulate(files.begin(), files.end(), std::size_t(0), [](std::size_t v, const std::pair<std::string, std::size_t>& p) {
+            return v + p.second;
+        });
     }
 
     void reportOut(const std::string &outmsg, Color c) override

gui/checkthread.cpp

@@ -398,9 +398,9 @@ void CheckThread::parseClangErrors(const QString &tool, const QString &file0, QS
             continue;
 
         std::list<ErrorMessage::FileLocation> callstack;
-        for (const QErrorPathItem &path : e.errorPath) {
-            callstack.emplace_back(path.file.toStdString(), path.info.toStdString(), path.line, path.column);
-        }
+        std::transform(e.errorPath.begin(), e.errorPath.end(), std::back_inserter(callstack), [](const QErrorPathItem& path) {
+            return ErrorMessage::FileLocation(path.file.toStdString(), path.info.toStdString(), path.line, path.column);
+        });
         const std::string f0 = file0.toStdString();
         const std::string msg = e.message.toStdString();
         const std::string id = e.errorId.toStdString();
@@ -411,11 +411,9 @@ void CheckThread::parseClangErrors(const QString &tool, const QString &file0, QS
 
 bool CheckThread::isSuppressed(const Suppressions::ErrorMessage &errorMessage) const
 {
-    for (const Suppressions::Suppression &suppression : mSuppressions) {
-        if (suppression.isSuppressed(errorMessage))
-            return true;
-    }
-    return false;
+    return std::any_of(mSuppressions.begin(), mSuppressions.end(), [&](const Suppressions::Suppression& s) {
+        return s.isSuppressed(errorMessage);
+    });
 }
 
 QString CheckThread::clangCmd()

gui/filelist.cpp

@@ -110,9 +110,9 @@ void FileList::addExcludeList(const QStringList &paths)
 static std::vector<std::string> toStdStringList(const QStringList &stringList)
 {
     std::vector<std::string> ret;
-    for (const QString &s : stringList) {
-        ret.push_back(s.toStdString());
-    }
+    std::transform(stringList.begin(), stringList.end(), std::back_inserter(ret), [](const QString& s) {
+        return s.toStdString();
+    });
     return ret;
 }
 

gui/main.cpp

@@ -57,11 +57,13 @@ int main(int argc, char *argv[])
     QSettings* settings = new QSettings("Cppcheck", "Cppcheck-GUI", &app);
 
     // Set data dir..
-    for (const QString& arg : QApplication::arguments()) {
-        if (arg.startsWith("--data-dir=")) {
-            settings->setValue("DATADIR", arg.mid(11));
-            return 0;
-        }
+    const QStringList args = QApplication::arguments();
+    auto it = std::find_if(args.begin(), args.end(), [](const QString& arg) {
+        return arg.startsWith("--data-dir=");
+    });
+    if (it != args.end()) {
+        settings->setValue("DATADIR", it->mid(11));
+        return 0;
     }
 
     TranslationHandler* th = new TranslationHandler(&app);

gui/mainwindow.cpp

@@ -451,9 +451,10 @@ void MainWindow::doAnalyzeProject(ImportProject p, const bool checkLibrary, cons
     mIsLogfileLoaded = false;
     if (mProjectFile) {
         std::vector<std::string> v;
-        for (const QString &i : mProjectFile->getExcludedPaths()) {
-            v.push_back(i.toStdString());
-        }
+        const QStringList excluded = mProjectFile->getExcludedPaths();
+        std::transform(excluded.begin(), excluded.end(), std::back_inserter(v), [](const QString& e) {
+            return e.toStdString();
+        });
         p.ignorePaths(v);
 
         if (!mProjectFile->getAnalyzeAllVsConfigs()) {
@@ -554,8 +555,9 @@ void MainWindow::doAnalyzeFiles(const QStringList &files, const bool checkLibrar
     if (!checkSettings.buildDir.empty()) {
         checkSettings.loadSummaries();
         std::list<std::string> sourcefiles;
-        for (const QString& s: fileNames)
-            sourcefiles.push_back(s.toStdString());
+        std::transform(fileNames.begin(), fileNames.end(), std::back_inserter(sourcefiles), [](const QString& s) {
+            return s.toStdString();
+        });
         AnalyzerInformation::writeFilesTxt(checkSettings.buildDir, sourcefiles, checkSettings.userDefines, checkSettings.project.fileSettings);
     }
 

lib/check.cpp

@@ -35,13 +35,13 @@
 Check::Check(const std::string &aname)
     : mTokenizer(nullptr), mSettings(nullptr), mErrorLogger(nullptr), mName(aname)
 {
-    for (std::list<Check*>::iterator i = instances().begin(); i != instances().end(); ++i) {
-        if ((*i)->name() > aname) {
-            instances().insert(i, this);
-            return;
-        }
-    }
-    instances().push_back(this);
+    auto it = std::find_if(instances().begin(), instances().end(), [&](const Check* i) {
+        return i->name() > aname;
+    });
+    if (it == instances().end())
+        instances().push_back(this);
+    else
+        instances().insert(it, this);
 }
 
 void Check::reportError(const ErrorMessage &errmsg)

lib/checkautovariables.cpp

@@ -418,10 +418,10 @@ static bool isInScope(const Token * tok, const Scope * scope)
         const Scope * tokScope = tok->scope();
         if (!tokScope)
             return false;
-        for (const Scope * argScope:tokScope->nestedList) {
-            if (argScope && argScope->isNestedIn(scope))
-                return true;
-        }
+        if (std::any_of(tokScope->nestedList.begin(), tokScope->nestedList.end(), [&](const Scope* argScope) {
+            return argScope && argScope->isNestedIn(scope);
+        }))
+            return true;
     }
     return false;
 }