Config file parsing (#1)

* config file parsing

* refactor + rename matchArgs -> startsWith

* remove indivual arguments, add 'args' key to config

Author: ludviggunne

Makefile

@@ -0,0 +1,15 @@
+CXXFLAGS=-Wall -Wextra -Wpedantic
+SRC=main.cpp\
+    config.cpp
+OBJ=$(SRC:%.cpp=%.o)
+
+run-cppcheck: $(OBJ)
+	$(CXX) $(LDFLAGS) -o $@ $^
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -o $@ -c $<
+
+clean:
+	rm -f run-cppcheck *.o
+
+.PHONY: clean

config.cpp

@@ -0,0 +1,140 @@
+#include "config.h"
+#include "picojson.h"
+
+#include <fstream>
+#include <vector>
+#include <cstring>
+#include <cerrno>
+
+std::string Config::load(const std::filesystem::path &path)
+{
+    // Read config file
+    std::ifstream ifs(path);
+    if (ifs.fail())
+        return std::strerror(errno);
+
+    std::streampos length;
+    ifs.seekg(0, std::ios::end);
+    length = ifs.tellg();
+    ifs.seekg(0, std::ios::beg);
+
+    std::vector<char> buffer(length);
+    ifs.read(&buffer[0], length);
+
+    if (ifs.fail())
+        return std::strerror(errno);
+
+    std::string text = buffer.data();
+
+    // Parse JSON
+    picojson::value data;
+    std::string err = picojson::parse(data, text);
+    if (!err.empty()) {
+        return err;
+    }
+
+    if (!data.is<picojson::object>()) 
+        return "Invalid config format";
+
+    const picojson::object &obj = data.get<picojson::object>();
+
+    // Read settings
+    for (auto [key, value] : obj) {
+
+        if (key == "project_file") {
+            if (!value.is<std::string>()) {
+                return "Invalid value type for '" + key + "'";
+            }
+            m_projectFilePath = value.get<std::string>();
+            continue;
+        }
+
+        if (key == "cppcheck") {
+            if (!value.is<std::string>()) {
+                return "Invalid value type for '" + key + "'";
+            }
+            m_cppcheck = value.get<std::string>();
+            continue;
+        }
+
+        if (key == "args") {
+            if (!value.is<picojson::array>())
+                return "Invalid value type for '" + key + "'";
+
+            for (auto arg : value.get<picojson::array>()) {
+                if (!arg.is<std::string>())
+                    return "Invalid value type for array element in '" + key + "'";
+                m_args.push_back(arg.get<std::string>());
+            }
+            continue;
+        }
+
+        return "Invalid config key '" + key + "'";
+    }
+
+    return "";
+}
+
+std::string Config::command() const
+{
+    std::string cmd;
+
+    cmd += m_cppcheck;
+
+    for (auto arg : m_args)
+        cmd += " " + arg;
+
+    if (!m_projectFilePath.empty()) {
+
+        std::string filter = m_filename;
+        if (std::strchr(filter.c_str(), ' '))
+            filter = "\"" + filter + "\"";
+
+        cmd += " --project=" + m_projectFilePath.string() + " --file-filter=" + filter;
+
+    } else {
+        cmd += " " + m_filename;
+    }
+
+    cmd += " 2>&1";
+
+    return cmd;
+}
+
+static const char *startsWith(const char *arg, const char *start) {
+    if (std::strncmp(arg, start, std::strlen(start)) != 0)
+        return NULL;
+    return arg + std::strlen(start);
+}
+
+std::string Config::parseArgs(int argc, char **argv)
+{
+    (void) argc;
+
+    ++argv;
+
+    for (; *argv; ++argv) {
+        const char *arg = *argv;
+        const char *value;
+
+        if ((value = startsWith(arg, "--config="))) {
+            std::string err = load(value);
+            if (!err.empty())
+                return "Failed to load config file '" + std::string(value) + "': " + err;
+            continue;
+        }
+
+        if (arg[0] == '-')
+            return "Invalid option '" + std::string(arg) + "'";
+
+        if (!m_filename.empty())
+            return "Multiple filenames provided";
+
+        m_filename = arg;
+    }
+
+    if (m_filename.empty())
+        return "Missing filename";
+
+    return "";
+}

config.h

@@ -0,0 +1,38 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include <filesystem>
+#include <vector>
+#include <string>
+
+class Config {
+public:
+    Config()
+        : m_projectFilePath("")
+        , m_cppcheck("cppcheck")
+        , m_filename("")
+        , m_args({})
+    {
+    }
+
+    /* Load config file.
+     * Returns an empty string on success, or an error message
+     * on failure. */
+    std::string load(const std::filesystem::path &path);
+
+    /* Construct cppcheck command string */
+    std::string command() const;
+
+    /* Read command line arguments.
+     * Returns an empty string on success, or an error message
+     * on failure. */
+    std::string parseArgs(int argc, char **argv);
+
+private:
+    std::filesystem::path m_projectFilePath = "";
+    std::string m_cppcheck;
+    std::string m_filename;
+    std::vector<std::string> m_args;
+};
+
+#endif

main.cpp

@@ -0,0 +1,84 @@
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <cstring>
+#include <cstdlib>
+#include <filesystem>
+
+#include <sys/stat.h>  // stat
+
+#include "config.h"
+
+std::ofstream logfile;
+
+
+/**
+ * Execute a shell command and read the output from it. Returns true if command terminated successfully.
+ */
+static int executeCommand(const std::string& cmd, std::string &output)
+{
+    output.clear();
+
+#ifdef _WIN32
+    FILE* p = _popen(cmd.c_str(), "r");
+#else
+    FILE *p = popen(cmd.c_str(), "r");
+#endif
+    if (!p) {
+        // TODO: how to provide to caller?
+        const int err = errno;
+        logfile << "popen() errno " << std::to_string(err) << std::endl;
+        return EXIT_FAILURE;
+    }
+    char buffer[1024];
+    while (fgets(buffer, sizeof(buffer), p) != nullptr)
+        output += buffer;
+
+#ifdef _WIN32
+    const int res = _pclose(p);
+#else
+    const int res = pclose(p);
+#endif
+    if (res == -1) { // error occurred
+        // TODO: how to provide to caller?
+        const int err = errno;
+        logfile << "pclose() errno " << std::to_string(err) << std::endl;
+        return res;
+    }
+#if !defined(WIN32) && !defined(__MINGW32__)
+    if (WIFEXITED(res)) {
+        return WEXITSTATUS(res);
+    }
+    if (WIFSIGNALED(res)) {
+        return WTERMSIG(res);
+    }
+#endif
+    return res;
+}
+
+int main(int argc, char** argv) {
+
+    const std::string log_path = std::filesystem::current_path() / "log.txt";
+    logfile.open(log_path, std::ios_base::app);
+
+    Config config;
+
+    const std::string err = config.parseArgs(argc, argv);
+    if (!err.empty()) {
+        std::cerr << "error: " << err << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    const std::string cmd = config.command();
+
+    logfile << "CMD:" << cmd << std::endl;
+
+    std::string output;
+    int res = executeCommand(cmd, output);
+
+    std::cerr << output;
+    logfile << output;
+
+    return res;
+}