moved some classes/structs into anonymous namespace

cli/cppcheckexecutor.cpp

@@ -72,42 +72,44 @@
 #include <windows.h>
 #endif
 
-class XMLErrorMessagesLogger : public ErrorLogger
-{
-    void reportOut(const std::string & outmsg, Color /*c*/ = Color::Reset) override
-    {
-        std::cout << outmsg << std::endl;
-    }
-
-    void reportErr(const ErrorMessage &msg) override
+namespace {
+    class XMLErrorMessagesLogger : public ErrorLogger
     {
-        reportOut(msg.toXML());
-    }
+        void reportOut(const std::string & outmsg, Color /*c*/ = Color::Reset) override
+        {
+            std::cout << outmsg << std::endl;
+        }
 
-    void reportProgress(const std::string & /*filename*/, const char /*stage*/[], const std::size_t /*value*/) override
-    {}
-};
+        void reportErr(const ErrorMessage &msg) override
+        {
+            reportOut(msg.toXML());
+        }
 
-class CmdLineLoggerStd : public CmdLineLogger
-{
-public:
-    CmdLineLoggerStd() = default;
+        void reportProgress(const std::string & /*filename*/, const char /*stage*/[], const std::size_t /*value*/) override
+        {}
+    };
 
-    void printMessage(const std::string &message) override
+    class CmdLineLoggerStd : public CmdLineLogger
     {
-        printRaw("cppcheck: " + message);
-    }
+    public:
+        CmdLineLoggerStd() = default;
 
-    void printError(const std::string &message) override
-    {
-        printMessage("error: " + message);
-    }
+        void printMessage(const std::string &message) override
+        {
+            printRaw("cppcheck: " + message);
+        }
 
-    void printRaw(const std::string &message) override
-    {
-        std::cout << message << std::endl;
-    }
-};
+        void printError(const std::string &message) override
+        {
+            printMessage("error: " + message);
+        }
+
+        void printRaw(const std::string &message) override
+        {
+            std::cout << message << std::endl;
+        }
+    };
+}
 
 class CppCheckExecutor::StdLogger : public ErrorLogger
 {

cli/processexecutor.cpp

@@ -68,59 +68,61 @@ ProcessExecutor::ProcessExecutor(const std::list<std::pair<std::string, std::siz
     assert(mSettings.jobs > 1);
 }
 
-class PipeWriter : public ErrorLogger {
-public:
-    enum PipeSignal {REPORT_OUT='1',REPORT_ERROR='2', CHILD_END='5'};
+namespace {
+    class PipeWriter : public ErrorLogger {
+    public:
+        enum PipeSignal {REPORT_OUT='1',REPORT_ERROR='2', CHILD_END='5'};
 
-    explicit PipeWriter(int pipe) : mWpipe(pipe) {}
+        explicit PipeWriter(int pipe) : mWpipe(pipe) {}
 
-    void reportOut(const std::string &outmsg, Color c) override {
-        writeToPipe(REPORT_OUT, static_cast<char>(c) + outmsg);
-    }
-
-    void reportErr(const ErrorMessage &msg) override {
-        writeToPipe(REPORT_ERROR, msg.serialize());
-    }
-
-    void writeEnd(const std::string& str) const {
-        writeToPipe(CHILD_END, str);
-    }
+        void reportOut(const std::string &outmsg, Color c) override {
+            writeToPipe(REPORT_OUT, static_cast<char>(c) + outmsg);
+        }
 
-private:
-    // TODO: how to log file name in error?
-    void writeToPipeInternal(PipeSignal type, const void* data, std::size_t to_write) const
-    {
-        const ssize_t bytes_written = write(mWpipe, data, to_write);
-        if (bytes_written <= 0) {
-            const int err = errno;
-            std::cerr << "#### ThreadExecutor::writeToPipeInternal() error for type " << type << ": " << std::strerror(err) << std::endl;
-            std::exit(EXIT_FAILURE);
+        void reportErr(const ErrorMessage &msg) override {
+            writeToPipe(REPORT_ERROR, msg.serialize());
         }
-        // TODO: write until everything is written
-        if (bytes_written != to_write) {
-            std::cerr << "#### ThreadExecutor::writeToPipeInternal() error for type " << type << ": insufficient data written (expected: " << to_write << " / got: " << bytes_written << ")" << std::endl;
-            std::exit(EXIT_FAILURE);
+
+        void writeEnd(const std::string& str) const {
+            writeToPipe(CHILD_END, str);
         }
-    }
 
-    void writeToPipe(PipeSignal type, const std::string &data) const
-    {
+    private:
+        // TODO: how to log file name in error?
+        void writeToPipeInternal(PipeSignal type, const void* data, std::size_t to_write) const
         {
-            const char t = static_cast<char>(type);
-            writeToPipeInternal(type, &t, 1);
+            const ssize_t bytes_written = write(mWpipe, data, to_write);
+            if (bytes_written <= 0) {
+                const int err = errno;
+                std::cerr << "#### ThreadExecutor::writeToPipeInternal() error for type " << type << ": " << std::strerror(err) << std::endl;
+                std::exit(EXIT_FAILURE);
+            }
+            // TODO: write until everything is written
+            if (bytes_written != to_write) {
+                std::cerr << "#### ThreadExecutor::writeToPipeInternal() error for type " << type << ": insufficient data written (expected: " << to_write << " / got: " << bytes_written << ")" << std::endl;
+                std::exit(EXIT_FAILURE);
+            }
         }
 
-        const unsigned int len = static_cast<unsigned int>(data.length());
+        void writeToPipe(PipeSignal type, const std::string &data) const
         {
-            static constexpr std::size_t l_size = sizeof(unsigned int);
-            writeToPipeInternal(type, &len, l_size);
-        }
+            {
+                const char t = static_cast<char>(type);
+                writeToPipeInternal(type, &t, 1);
+            }
 
-        writeToPipeInternal(type, data.c_str(), len);
-    }
+            const unsigned int len = static_cast<unsigned int>(data.length());
+            {
+                static constexpr std::size_t l_size = sizeof(unsigned int);
+                writeToPipeInternal(type, &len, l_size);
+            }
 
-    const int mWpipe;
-};
+            writeToPipeInternal(type, data.c_str(), len);
+        }
+
+        const int mWpipe;
+    };
+}
 
 bool ProcessExecutor::handleRead(int rpipe, unsigned int &result, const std::string& filename)
 {

gui/librarydialog.cpp

@@ -47,18 +47,20 @@ class QWidget;
 
 // TODO: get/compare functions from header
 
-class FunctionListItem : public QListWidgetItem {
-public:
-    FunctionListItem(QListWidget *view,
-                     CppcheckLibraryData::Function *function,
-                     bool selected)
-        : QListWidgetItem(view), function(function) {
-        setText(function->name);
-        setFlags(flags() | Qt::ItemIsEditable);
-        setSelected(selected);
-    }
-    CppcheckLibraryData::Function *function;
-};
+namespace {
+    class FunctionListItem : public QListWidgetItem {
+    public:
+        FunctionListItem(QListWidget *view,
+                         CppcheckLibraryData::Function *function,
+                         bool selected)
+            : QListWidgetItem(view), function(function) {
+            setText(function->name);
+            setFlags(flags() | Qt::ItemIsEditable);
+            setSelected(selected);
+        }
+        CppcheckLibraryData::Function *function;
+    };
+}
 
 LibraryDialog::LibraryDialog(QWidget *parent) :
     QDialog(parent),

lib/astutils.cpp

@@ -2943,27 +2943,29 @@ static const Token* findExpressionChangedImpl(const Token* expr,
     return result;
 }
 
-struct ExpressionChangedSimpleFind {
-    template<class F>
-    const Token* operator()(const Token* start, const Token* end, F f) const
-    {
-        return findToken(start, end, f);
-    }
-};
-
-struct ExpressionChangedSkipDeadCode {
-    const Library* library;
-    const std::function<std::vector<MathLib::bigint>(const Token* tok)>* evaluate;
-    ExpressionChangedSkipDeadCode(const Library* library,
-                                  const std::function<std::vector<MathLib::bigint>(const Token* tok)>& evaluate)
-        : library(library), evaluate(&evaluate)
-    {}
-    template<class F>
-    const Token* operator()(const Token* start, const Token* end, F f) const
-    {
-        return findTokenSkipDeadCode(library, start, end, f, *evaluate);
-    }
-};
+namespace {
+    struct ExpressionChangedSimpleFind {
+        template<class F>
+        const Token* operator()(const Token* start, const Token* end, F f) const
+        {
+            return findToken(start, end, f);
+        }
+    };
+
+    struct ExpressionChangedSkipDeadCode {
+        const Library* library;
+        const std::function<std::vector<MathLib::bigint>(const Token* tok)>* evaluate;
+        ExpressionChangedSkipDeadCode(const Library* library,
+                                      const std::function<std::vector<MathLib::bigint>(const Token* tok)>& evaluate)
+            : library(library), evaluate(&evaluate)
+        {}
+        template<class F>
+        const Token* operator()(const Token* start, const Token* end, F f) const
+        {
+            return findTokenSkipDeadCode(library, start, end, f, *evaluate);
+        }
+    };
+}
 
 const Token* findExpressionChanged(const Token* expr,
                                    const Token* start,

lib/checkio.cpp

@@ -107,19 +107,19 @@ static OpenMode getMode(const std::string& str)
     return OpenMode::UNKNOWN_OM;
 }
 
-struct Filepointer {
-    OpenMode mode;
-    nonneg int mode_indent{};
-    enum class Operation {NONE, UNIMPORTANT, READ, WRITE, POSITIONING, OPEN, CLOSE, UNKNOWN_OP} lastOperation = Operation::NONE;
-    nonneg int op_indent{};
-    enum class AppendMode { UNKNOWN_AM, APPEND, APPEND_EX };
-    AppendMode append_mode = AppendMode::UNKNOWN_AM;
-    std::string filename;
-    explicit Filepointer(OpenMode mode_ = OpenMode::UNKNOWN_OM)
-        : mode(mode_) {}
-};
-
 namespace {
+    struct Filepointer {
+        OpenMode mode;
+        nonneg int mode_indent{};
+        enum class Operation {NONE, UNIMPORTANT, READ, WRITE, POSITIONING, OPEN, CLOSE, UNKNOWN_OP} lastOperation = Operation::NONE;
+        nonneg int op_indent{};
+        enum class AppendMode { UNKNOWN_AM, APPEND, APPEND_EX };
+        AppendMode append_mode = AppendMode::UNKNOWN_AM;
+        std::string filename;
+        explicit Filepointer(OpenMode mode_ = OpenMode::UNKNOWN_OM)
+            : mode(mode_) {}
+    };
+
     const std::unordered_set<std::string> whitelist = { "clearerr", "feof", "ferror", "fgetpos", "ftell", "setbuf", "setvbuf", "ungetc", "ungetwc" };
 }