make it possible to pass char buffer to simplecpp

Author: firewave

democlient/democlient.cpp

@@ -66,8 +66,9 @@ class CppcheckExecutor : public ErrorLogger {
         , cppcheck(settings, supprs, *this, false, nullptr)
     {}
 
-    void run(const char code[]) {
-        cppcheck.check(FileWithDetails("test.cpp", Standards::Language::CPP, 0), code);
+    template<std::size_t size>
+    void run(const char (&code)[size]) {
+        cppcheck.check(FileWithDetails("test.cpp", Standards::Language::CPP, 0), reinterpret_cast<const uint8_t*>(code), size-1);
     }
 
     void reportOut(const std::string & /*outmsg*/, Color /*c*/) override {}

gui/mainwindow.cpp

@@ -726,8 +726,11 @@ void MainWindow::analyzeCode(const QString& code, const QString& filename)
     checkLockDownUI();
     clearResults();
     mUI->mResults->checkingStarted(1);
-    // TODO: apply enforcedLanguage?
-    cppcheck.check(FileWithDetails(filename.toStdString(), Path::identify(filename.toStdString(), false), 0), code.toStdString());
+    {
+        const std::string code_s = code.toStdString();
+        // TODO: apply enforcedLanguage?
+        cppcheck.check(FileWithDetails(filename.toStdString(), Path::identify(filename.toStdString(), false), 0), reinterpret_cast<const std::uint8_t*>(code_s.data()), code_s.size());
+    }
     analysisDone();
 
     // Expand results

lib/cppcheck.cpp

@@ -799,10 +799,9 @@ unsigned int CppCheck::check(const FileWithDetails &file)
     return returnValue;
 }
 
-unsigned int CppCheck::check(const FileWithDetails &file, const std::string &content)
+unsigned int CppCheck::check(const FileWithDetails &file, const uint8_t* data, std::size_t size)
 {
-    std::istringstream iss(content);
-    return checkFile(file, "", 0, &iss);
+    return checkBuffer(file, "", 0, data, size);
 }
 
 unsigned int CppCheck::check(const FileSettings &fs)
@@ -851,12 +850,26 @@ unsigned int CppCheck::check(const FileSettings &fs)
     return returnValue;
 }
 
-static simplecpp::TokenList createTokenList(const std::string& filename, std::vector<std::string>& files, simplecpp::OutputList* outputList, std::istream* fileStream)
+unsigned int CppCheck::checkBuffer(const FileWithDetails &file, const std::string &cfgname, int fileIndex, const uint8_t* data, std::size_t size)
 {
-    if (fileStream)
-        return {*fileStream, files, filename, outputList};
+    return checkInternal(file, cfgname, fileIndex,
+                         [&file, data, size](std::vector<std::string>& files) {
+        return simplecpp::TokenList{data, size, files, file.spath()};
+    },
+                         [&file, data, size](std::vector<std::string>& files, simplecpp::OutputList* outputList) {
+        return simplecpp::TokenList{data, size, files, file.spath(), outputList};
+    });
+}
 
-    return {filename, files, outputList};
+unsigned int CppCheck::checkStream(const FileWithDetails &file, const std::string &cfgname, int fileIndex, std::istream& fileStream)
+{
+    return checkInternal(file, cfgname, fileIndex,
+                         [&fileStream](std::vector<std::string>& files) {
+       return simplecpp::TokenList{fileStream, files};
+    },
+                         [&file, &fileStream](std::vector<std::string>& files, simplecpp::OutputList* outputList) {
+        return simplecpp::TokenList{fileStream, files, file.spath(), outputList};
+    });
 }
 
 std::size_t CppCheck::calculateHash(const Preprocessor& preprocessor, const simplecpp::TokenList& tokens, const std::string& filePath) const
@@ -880,7 +893,18 @@ std::size_t CppCheck::calculateHash(const Preprocessor& preprocessor, const simp
     return preprocessor.calculateHash(tokens, toolinfo.str());
 }
 
-unsigned int CppCheck::checkFile(const FileWithDetails& file, const std::string &cfgname, int fileIndex, std::istream* fileStream)
+unsigned int CppCheck::checkFile(const FileWithDetails& file, const std::string &cfgname, int fileIndex)
+{
+    return checkInternal(file, cfgname, fileIndex,
+                         [&file](std::vector<std::string>& files) {
+        return simplecpp::TokenList{file.spath(), files};
+    },
+                         [&file](std::vector<std::string>& files, simplecpp::OutputList* outputList) {
+        return simplecpp::TokenList{file.spath(), files, outputList};
+    });
+}
+
+unsigned int CppCheck::checkInternal(const FileWithDetails& file, const std::string &cfgname, int fileIndex, const CreateTokensFn& createTokens, const CreateTokenListFn& createTokenList)
 {
     // TODO: move to constructor when CppCheck no longer owns the settings
     if (mSettings.checks.isEnabled(Checks::unusedFunction) && !mUnusedFunctionsCheck)
@@ -931,24 +955,13 @@ unsigned int CppCheck::checkFile(const FileWithDetails& file, const std::string
                 std::size_t hash = 0;
                 // markup files are special and do not adhere to the enforced language
                 TokenList tokenlist{mSettings, Standards::Language::C};
-                if (fileStream) {
-                    std::vector<std::string> files;
-                    simplecpp::TokenList tokens(*fileStream, files, file.spath());
-                    if (analyzerInformation) {
-                        const Preprocessor preprocessor(mSettings, mErrorLogger, Standards::Language::C);
-                        hash = calculateHash(preprocessor, tokens);
-                    }
-                    tokenlist.createTokens(std::move(tokens));
-                }
-                else {
-                    std::vector<std::string> files;
-                    simplecpp::TokenList tokens(file.spath(), files);
-                    if (analyzerInformation) {
-                        const Preprocessor preprocessor(mSettings, mErrorLogger, file.lang());
-                        hash = calculateHash(preprocessor, tokens);
-                    }
-                    tokenlist.createTokens(std::move(tokens));
+                std::vector<std::string> files;
+                simplecpp::TokenList tokens = createTokens(files);
+                if (analyzerInformation) {
+                    const Preprocessor preprocessor(mSettings, mErrorLogger, file.lang());
+                    hash = calculateHash(preprocessor, tokens);
                 }
+                tokenlist.createTokens(std::move(tokens));
                 // this is not a real source file - we just want to tokenize it. treat it as C anyways as the language needs to be determined.
                 Tokenizer tokenizer(std::move(tokenlist), mErrorLogger);
                 mUnusedFunctionsCheck->parseTokens(tokenizer, mSettings);
@@ -967,7 +980,7 @@ unsigned int CppCheck::checkFile(const FileWithDetails& file, const std::string
 
         simplecpp::OutputList outputList;
         std::vector<std::string> files;
-        simplecpp::TokenList tokens1 = createTokenList(file.spath(), files, &outputList, fileStream);
+        simplecpp::TokenList tokens1 = createTokenList(files, &outputList);
 
         // If there is a syntax error, report it and stop
         const auto output_it = std::find_if(outputList.cbegin(), outputList.cend(), [](const simplecpp::Output &output){

lib/cppcheck.h

@@ -45,7 +45,10 @@ class Settings;
 struct Suppressions;
 class Preprocessor;
 
-namespace simplecpp { class TokenList; }
+namespace simplecpp {
+    class TokenList;
+    struct Output;
+}
 
 /// @addtogroup Core
 /// @{
@@ -100,12 +103,13 @@ class CPPCHECKLIB CppCheck {
      * the disk but the content is given in @p content. In errors the @p path
      * is used as a filename.
      * @param file The file to check.
-     * @param content File content as a string.
+     * @param data File content as a buffer.
+     * @param size Size of buffer.
      * @return amount of errors found or 0 if none were found.
      * @note You must set settings before calling this function (by calling
      *  settings()).
      */
-    unsigned int check(const FileWithDetails &file, const std::string &content);
+    unsigned int check(const FileWithDetails &file, const uint8_t* data, std::size_t size);
 
     /**
      * @brief Returns current version number as a string.
@@ -181,7 +185,40 @@ class CPPCHECKLIB CppCheck {
      * @param fileStream stream the file content can be read from
      * @return number of errors found
      */
-    unsigned int checkFile(const FileWithDetails& file, const std::string &cfgname, int fileIndex, std::istream* fileStream = nullptr);
+    unsigned int checkStream(const FileWithDetails& file, const std::string &cfgname, int fileIndex, std::istream& fileStream);
+
+
+    /**
+     * @brief Check a file
+     * @param file the file
+     * @param cfgname  cfg name
+     * @return number of errors found
+     */
+    unsigned int checkFile(const FileWithDetails& file, const std::string &cfgname, int fileIndex);
+
+    /**
+     * @brief Check a file using buffer
+     * @param file the file
+     * @param cfgname  cfg name
+     * @param data the data to be read
+     * @param size the size of the data to be read
+     * @return number of errors found
+     */
+    unsigned int checkBuffer(const FileWithDetails& file, const std::string &cfgname, int fileIndex, const uint8_t* data, std::size_t size);
+
+    using CreateTokensFn = std::function<simplecpp::TokenList (std::vector<std::string>& files)>;
+    // TODO: should use simplecpp::OutputList
+    using CreateTokenListFn = std::function<simplecpp::TokenList (std::vector<std::string>&, std::list<simplecpp::Output>*)>;
+
+    /**
+     * @brief Check a file using stream
+     * @param file the file
+     * @param cfgname  cfg name
+     * @param createTokens a function to create the tokens with
+     * @param createTokenList a function to create the TokenList with
+     * @return number of errors found
+     */
+    unsigned int checkInternal(const FileWithDetails& file, const std::string &cfgname, int fileIndex, const CreateTokensFn& createTokens, const CreateTokenListFn& createTokenList);
 
     /**
      * @brief Check normal tokens

lib/tokenlist.cpp

@@ -328,6 +328,13 @@ bool TokenList::createTokens(std::istream &code)
 
 //---------------------------------------------------------------------------
 
+bool TokenList::createTokens(const uint8_t* data, size_t size)
+{
+    return createTokensInternal(data, size, mFiles.empty() ? "" : *mFiles.cbegin());
+}
+
+//---------------------------------------------------------------------------
+
 bool TokenList::createTokensInternal(std::istream &code, const std::string& file0)
 {
     simplecpp::OutputList outputList;
@@ -340,6 +347,18 @@ bool TokenList::createTokensInternal(std::istream &code, const std::string& file
 
 //---------------------------------------------------------------------------
 
+bool TokenList::createTokensInternal(const uint8_t* data, size_t size, const std::string& file0)
+{
+    simplecpp::OutputList outputList;
+    simplecpp::TokenList tokens(data, size, mFiles, file0, &outputList);
+
+    createTokens(std::move(tokens));
+
+    return outputList.empty();
+}
+
+//---------------------------------------------------------------------------
+
 // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
 void TokenList::createTokens(simplecpp::TokenList&& tokenList)
 {

lib/tokenlist.h

@@ -101,6 +101,14 @@ class CPPCHECKLIB TokenList {
      * @param code input stream for code
      */
     bool createTokens(std::istream &code);
+    bool createTokens(const uint8_t* data, size_t size);
+    bool createTokens(const char* data, size_t size) {
+        return createTokens(reinterpret_cast<const uint8_t*>(data), size);
+    }
+    template<size_t size>
+    bool createTokens(const char (&data)[size]) {
+        return createTokens(reinterpret_cast<const uint8_t*>(data), size-1);
+    }
 
     void createTokens(simplecpp::TokenList&& tokenList);
 
@@ -209,6 +217,7 @@ class CPPCHECKLIB TokenList {
 
 private:
     bool createTokensInternal(std::istream &code, const std::string& file0);
+    bool createTokensInternal(const uint8_t* data, std::size_t size, const std::string& file0);
 
     /** Token list */
     std::shared_ptr<TokensFrontBack> mTokensFrontBack;

oss-fuzz/main.cpp

@@ -60,11 +60,11 @@ static const Settings s_settings = create_settings();
 static DummyErrorLogger s_errorLogger;
 static const FileWithDetails s_file("test.cpp", Standards::Language::CPP, 0);
 
-static void doCheck(const std::string& code)
+static void doCheck(const uint8_t *data, size_t dataSize)
 {
     Suppressions supprs;
     CppCheck cppcheck(s_settings, supprs, s_errorLogger, false, nullptr);
-    cppcheck.check(s_file, code);
+    cppcheck.check(s_file, data, dataSize);
 }
 
 #ifndef NO_FUZZ
@@ -74,7 +74,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataSize)
 {
     if (dataSize < 10000) {
         const std::string code = generateCode2(data, dataSize);
-        doCheck(code);
+        doCheck(reinterpret_cast<const unsigned char*>(code.data()), code.size());
     }
     return 0;
 }
@@ -98,7 +98,7 @@ int main(int argc, char * argv[])
 
     const std::string code = oss.str();
     for (int i = 0; i < cnt; ++i)
-        doCheck(code);
+        doCheck(reinterpret_cast<const unsigned char*>(code.data()), code.size());
 
     return EXIT_SUCCESS;
 }

test/testsuppressions.cpp

@@ -1252,7 +1252,7 @@ class TestSuppressions : public TestFixture {
         CppCheck cppCheck(settings, supprs, *this, false, nullptr); // <- do not "use global suppressions". pretend this is a thread that just checks a file.
 
         const char code[] = "int f() { int a; return a; }";
-        ASSERT_EQUALS(0, cppCheck.check(FileWithDetails("test.c", Standards::Language::C, 0), code)); // <- no unsuppressed error is seen
+        ASSERT_EQUALS(0, cppCheck.check(FileWithDetails("test.c", Standards::Language::C, 0), reinterpret_cast<const std::uint8_t*>(code), sizeof(code))); // <- no unsuppressed error is seen
         ASSERT_EQUALS("[test.c:1:25]: (error) Uninitialized variable: a [uninitvar]\n", errout_str()); // <- report error so ThreadExecutor can suppress it and make sure the global suppression is matched.
     }
 
@@ -1296,7 +1296,7 @@ class TestSuppressions : public TestFixture {
             "    int y;\n"
             "};";
         CppCheck cppCheck(settings, supprs, *this, true, nullptr);
-        ASSERT_EQUALS(0, cppCheck.check(FileWithDetails("/somewhere/test.cpp", Standards::Language::CPP, 0), code));
+        ASSERT_EQUALS(0, cppCheck.check(FileWithDetails("/somewhere/test.cpp", Standards::Language::CPP, 0), reinterpret_cast<const std::uint8_t*>(code), sizeof(code)));
         ASSERT_EQUALS("",errout_str());
     }