mitigated bugprone-assignment-in-selection-statement clang-tidy warning

firewave · firewave · commit 85a76d40678b · 2026-07-11T16:12:58.000+02:00
fixed `readability-redundant-parentheses` clang-tidy warnings

mitigated `misc-explicit-constructor` clang-tidy warnings

disabled `-Wlifetime-safety-*` Clang warnings for now

mitigated `misc-const-correctness` clang-tidy warnings

.clang-tidy: disabled `bugprone-std-exception-baseclass` for now

.clang-tidy: disabled `bugprone-signed-bitwise` for now

mitigated `bugprone-unhandled-code-paths` clang-tidy warnings

.clang-tidy: disabled `readability-trailing-comma` clang-tidy check

.clang-tidy: removed disabling of `hicpp-*` checks as they no longer exist

clang-tidy.yml: updated to Clang 23
diff --git a/.clang-tidy b/.clang-tidy
@@ -10,7 +10,6 @@ Checks: >
         -cppcoreguidelines-*,
         -fuchsia-*,
         -google-*,
-        -hicpp-*,
         -linuxkernel-*,
         -llvm-*,
         -llvmlibc-*,
@@ -21,6 +20,8 @@ Checks: >
         -bugprone-branch-clone,
         -bugprone-easily-swappable-parameters,
         -bugprone-narrowing-conversions,
+        -bugprone-signed-bitwise,
+        -bugprone-std-exception-baseclass,
         -bugprone-switch-missing-default-case,
         -bugprone-throwing-static-initialization,
         -bugprone-unchecked-string-to-number-conversion,
@@ -42,6 +43,7 @@ Checks: >
         -readability-isolate-declaration,
         -readability-magic-numbers,
         -readability-redundant-inline-specifier,
+        -readability-trailing-comma,
         -readability-use-concise-preprocessor-directives,
         -readability-uppercase-literal-suffix,
         -performance-avoid-endl,
diff --git a/.github/workflows/clang-tidy.yml b/.github/workflows/clang-tidy.yml
@@ -33,19 +33,19 @@ jobs:
         run: |
           wget https://apt.llvm.org/llvm.sh
           chmod +x llvm.sh
-          sudo ./llvm.sh 22
-          sudo apt-get install clang-tidy-22
+          sudo ./llvm.sh 23
+          sudo apt-get install clang-tidy-23
 
       - name: Verify clang-tidy configuration
         run: |
-          clang-tidy-22 --verify-config
+          clang-tidy-23 --verify-config
 
       - name: Prepare CMake
         run: |
           cmake -S . -B cmake.output -Werror=dev --warn-uninitialized -DCMAKE_CXX_STANDARD=23 -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
         env:
-          CXX: clang-22
+          CXX: clang-23
 
       - name: Clang-Tidy
         run: |
-          run-clang-tidy-22 -q -j $(nproc) -enable-check-profile -p=cmake.output
+          run-clang-tidy-23 -q -j $(nproc) -enable-check-profile -p=cmake.output
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -73,6 +73,11 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     add_compile_options_safe(-Wno-thread-safety-negative)
     add_compile_options_safe(-Wno-thread-safety-beta)
 
+    # TODO: enable
+    add_compile_options_safe(-Wno-lifetime-safety-intra-tu-suggestions)
+    add_compile_options_safe(-Wno-lifetime-safety-intra-tu-constructor-suggestions)
+    add_compile_options_safe(-Wno-lifetime-safety-cross-tu-constructor-suggestions)
+
     # TODO: fix these?
     add_compile_options(-Wno-padded)
     add_compile_options(-Wno-sign-conversion)
diff --git a/main.cpp b/main.cpp
@@ -26,7 +26,7 @@ static bool isDir(const std::string& path)
     return (file_stat.st_mode & S_IFMT) == S_IFDIR;
 }
 
-int main(int argc, char **argv)
+int main(int argc, char *argv[])
 {
     bool error = false;
     const char *filename = nullptr;
@@ -49,6 +49,7 @@ int main(int argc, char **argv)
         if (*arg == '-') {
             bool found = false;
             const char c = arg[1];
+            // NOLINTNEXTLINE(bugprone-unhandled-code-paths)
             switch (c) {
             case 'D': { // define symbol
                 found = true;
diff --git a/simplecpp.cpp b/simplecpp.cpp
@@ -153,12 +153,12 @@ static bool endsWith(const std::string &s, const std::string &e)
     return (s.size() >= e.size()) && std::equal(e.rbegin(), e.rend(), s.rbegin());
 }
 
-static bool sameline(const simplecpp::Token *tok1, const simplecpp::Token *tok2)
+static bool sameline(const simplecpp::Token * const tok1, const simplecpp::Token * const tok2)
 {
     return tok1 && tok2 && tok1->location.sameline(tok2->location);
 }
 
-static bool isAlternativeBinaryOp(const simplecpp::Token *tok, const std::string &alt)
+static bool isAlternativeBinaryOp(const simplecpp::Token * const tok, const std::string &alt)
 {
     return (tok->name &&
             tok->str() == alt &&
@@ -168,7 +168,7 @@ static bool isAlternativeBinaryOp(const simplecpp::Token *tok, const std::string
             (tok->next->number || tok->next->name || tok->next->op == '('));
 }
 
-static bool isAlternativeUnaryOp(const simplecpp::Token *tok, const std::string &alt)
+static bool isAlternativeUnaryOp(const simplecpp::Token * const tok, const std::string &alt)
 {
     return ((tok->name && tok->str() == alt) &&
             (!tok->previous || tok->previous->op == '(') &&
@@ -622,7 +622,7 @@ static std::string escapeString(const std::string &str)
     return ostr.str();
 }
 
-static void portabilityBackslash(simplecpp::OutputList *outputList, const simplecpp::Location &location)
+static void portabilityBackslash(simplecpp::OutputList * const outputList, const simplecpp::Location &location)
 {
     if (!outputList)
         return;
@@ -799,7 +799,7 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
                 if (ch == '\\') {
                     TokenString tmp;
                     char tmp_ch = ch;
-                    while ((stream.good()) && (tmp_ch == '\\' || tmp_ch == ' ' || tmp_ch == '\t')) {
+                    while (stream.good() && (tmp_ch == '\\' || tmp_ch == ' ' || tmp_ch == '\t')) {
                         tmp += tmp_ch;
                         tmp_ch = stream.readChar();
                     }
@@ -999,7 +999,7 @@ void simplecpp::TokenList::constFold()
     }
 }
 
-static bool isFloatSuffix(const simplecpp::Token *tok)
+static bool isFloatSuffix(const simplecpp::Token * const tok)
 {
     if (!tok || tok->str().size() != 1U)
         return false;
@@ -1010,7 +1010,7 @@ static bool isFloatSuffix(const simplecpp::Token *tok)
 static const std::string AND("and");
 static const std::string BITAND("bitand");
 static const std::string BITOR("bitor");
-static bool isAlternativeAndBitandBitor(const simplecpp::Token* tok)
+static bool isAlternativeAndBitandBitor(const simplecpp::Token * const tok)
 {
     return isAlternativeBinaryOp(tok, AND) || isAlternativeBinaryOp(tok, BITAND) || isAlternativeBinaryOp(tok, BITOR);
 }
@@ -1699,7 +1699,7 @@ namespace simplecpp {
         };
 
         struct invalidDirectiveAsMacroParameter : public Error {
-            invalidDirectiveAsMacroParameter(const Location &loc)
+            explicit invalidDirectiveAsMacroParameter(const Location &loc)
                 : Error(loc, "it is invalid to use a preprocessor directive as macro parameter") {}
         };
 
@@ -2296,7 +2296,7 @@ namespace simplecpp {
          * @return token after B
          */
         const Token *expandHashHash(TokenList &output, const Location &loc, const Token *tok, const MacroMap &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens, bool expandResult=true) const {
-            Token *A = output.back();
+            Token * const A = output.back();
             if (!A)
                 throw invalidHashHash(tok->location, name(), "Missing first argument");
             if (!sameline(tok, tok->next) || !sameline(tok, tok->next->next))
@@ -3258,7 +3258,7 @@ static bool getFileId(const std::string &path, FileID &id)
 #endif
 }
 
-simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens, std::vector<std::string> &filenames, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, FileDataCache cache)
+simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens, std::vector<std::string> &filenames, const simplecpp::DUI &dui, simplecpp::OutputList * const outputList, FileDataCache cache)
 {
 #ifdef SIMPLECPP_WINDOWS
     if (dui.clearIncludeCache)
@@ -3341,7 +3341,7 @@ simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens,
     return cache;
 }
 
-static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token *&tok1, simplecpp::MacroMap &macros, std::vector<std::string> &files, simplecpp::OutputList *outputList)
+static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token *&tok1, simplecpp::MacroMap &macros, std::vector<std::string> &files, simplecpp::OutputList * const outputList)
 {
     const simplecpp::Token * const tok = tok1;
     const simplecpp::MacroMap::const_iterator it = tok->name ? macros.find(tok->str()) : macros.end();
@@ -3391,21 +3391,21 @@ static void getLocaltime(struct tm &ltime)
 #endif
 }
 
-static std::string getDateDefine(const struct tm *timep)
+static std::string getDateDefine(const struct tm * const timep)
 {
     char buf[] = "??? ?? ????";
     strftime(buf, sizeof(buf), "%b %d %Y", timep);
     return std::string("\"").append(buf).append("\"");
 }
 
-static std::string getTimeDefine(const struct tm *timep)
+static std::string getTimeDefine(const struct tm * const timep)
 {
     char buf[] = "??:??:??";
     strftime(buf, sizeof(buf), "%H:%M:%S", timep);
     return std::string("\"").append(buf).append("\"");
 }
 
-void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenList &rawtokens, std::vector<std::string> &files, simplecpp::FileDataCache &cache, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, std::list<simplecpp::MacroUsage> *macroUsage, std::list<simplecpp::IfCond> *ifCond)
+void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenList &rawtokens, std::vector<std::string> &files, simplecpp::FileDataCache &cache, const simplecpp::DUI &dui, simplecpp::OutputList * const outputList, std::list<simplecpp::MacroUsage> * const macroUsage, std::list<simplecpp::IfCond> * const ifCond)
 {
 #ifdef SIMPLECPP_WINDOWS
     if (dui.clearIncludeCache)
@@ -3783,6 +3783,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                                 std::string header;
 
                                 if (systemheader) {
+                                    // NOLINTNEXTLINE(bugprone-assignment-in-selection-statement)
                                     while ((tok = tok->next) && tok->op != '>')
                                         header += tok->str();
                                     if (tok && tok->op == '>')
diff --git a/simplecpp.h b/simplecpp.h
@@ -75,6 +75,7 @@ namespace simplecpp {
     struct View
     {
         // cppcheck-suppress noExplicitConstructor
+        // NOLINTNEXTLINE(misc-explicit-constructor)
         View(const char* data)
             : mData(data)
             , mSize(strlen(data))
@@ -88,6 +89,7 @@ namespace simplecpp {
         {}
 
         // cppcheck-suppress noExplicitConstructor
+        // NOLINTNEXTLINE(misc-explicit-constructor)
         View(const std::string& str)
             : mData(str.data())
             , mSize(str.size())
diff --git a/test.cpp b/test.cpp
@@ -86,7 +86,7 @@ static void assertThrowFailed(int line)
     std::cerr << "exception not thrown" << std::endl;
 }
 
-static void testcase(const std::string &name, void (*f)(), int argc, char * const *argv)
+static void testcase(const std::string &name, void (*const f)(), int argc, char *argv[])
 {
     if (argc == 1) {
         f();
@@ -101,7 +101,7 @@ static void testcase(const std::string &name, void (*f)(), int argc, char * cons
 
 #define TEST_CASE(F)    (testcase(#F, F, argc, argv))
 
-static simplecpp::TokenList makeTokenList(const char code[], std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList *outputList=nullptr)
+static simplecpp::TokenList makeTokenList(const char code[], std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList * const outputList=nullptr)
 {
     switch (USE_INPUT) {
     case Input::Stringstream: {
@@ -115,24 +115,24 @@ static simplecpp::TokenList makeTokenList(const char code[], std::size_t size, s
     return simplecpp::TokenList{filenames}; // unreachable - needed for GCC and Visual Studio
 }
 
-static simplecpp::TokenList makeTokenList(const char code[], std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList *outputList=nullptr)
+static simplecpp::TokenList makeTokenList(const char code[], std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList * const outputList=nullptr)
 {
     return makeTokenList(code, strlen(code), filenames, filename, outputList);
 }
 
-static std::string readfile(const char code[], simplecpp::OutputList *outputList=nullptr)
+static std::string readfile(const char code[], simplecpp::OutputList * const outputList=nullptr)
 {
     std::vector<std::string> files;
     return makeTokenList(code,files,std::string(),outputList).stringify();
 }
 
-static std::string readfile(const char code[], std::size_t size, simplecpp::OutputList *outputList=nullptr)
+static std::string readfile(const char code[], std::size_t size, simplecpp::OutputList * const outputList=nullptr)
 {
     std::vector<std::string> files;
     return makeTokenList(code,size,files,std::string(),outputList).stringify();
 }
 
-static std::string preprocess(const char code[], const simplecpp::DUI &dui, simplecpp::OutputList *outputList, std::list<simplecpp::MacroUsage> *macroUsage = nullptr, std::list<simplecpp::IfCond> *ifCond = nullptr, const std::string &file = std::string())
+static std::string preprocess(const char code[], const simplecpp::DUI &dui, simplecpp::OutputList * const outputList, std::list<simplecpp::MacroUsage> * const macroUsage = nullptr, std::list<simplecpp::IfCond> * const ifCond = nullptr, const std::string &file = std::string())
 {
     std::vector<std::string> files;
     simplecpp::FileDataCache cache;
@@ -160,17 +160,17 @@ static std::string preprocess(const char code[], const simplecpp::DUI &dui)
     return preprocess(code, dui, nullptr);
 }
 
-static std::string preprocess(const char code[], simplecpp::OutputList *outputList)
+static std::string preprocess(const char code[], simplecpp::OutputList * const outputList)
 {
     return preprocess(code, simplecpp::DUI(), outputList);
 }
 
-static std::string preprocess(const char code[], std::list<simplecpp::IfCond> *ifCond)
+static std::string preprocess(const char code[], std::list<simplecpp::IfCond> * const ifCond)
 {
     return preprocess(code, simplecpp::DUI(), nullptr, nullptr, ifCond);
 }
 
-static std::string preprocess(const char code[], std::list<simplecpp::MacroUsage> *macroUsage)
+static std::string preprocess(const char code[], std::list<simplecpp::MacroUsage> * const macroUsage)
 {
     return preprocess(code, simplecpp::DUI(), nullptr, macroUsage);
 }
@@ -3960,7 +3960,7 @@ static void leak()
     }
 }
 
-static void runTests(int argc, char **argv, Input input)
+static void runTests(int argc, char *argv[], Input input)
 {
     USE_INPUT = input;
 
@@ -4257,7 +4257,7 @@ static void runTests(int argc, char **argv, Input input)
     TEST_CASE(leak);
 }
 
-int main(int argc, char **argv)
+int main(int argc, char *argv[])
 {
     runTests(argc, argv, Input::Stringstream);
     runTests(argc, argv, Input::CharBuffer);

Original file line number	Diff line number	Diff line change
`@@ -153,12 +153,12 @@ static bool endsWith(const std::string &s, const std::string &e)`
`153`	`153`	`return (s.size() >= e.size()) && std::equal(e.rbegin(), e.rend(), s.rbegin());`
`154`	`154`	`}`
`155`	`155`
`156`		`-static bool sameline(const simplecpp::Token tok1, const simplecpp::Token tok2)`
	`156`	`+static bool sameline(const simplecpp::Token * const tok1, const simplecpp::Token * const tok2)`
`157`	`157`	`{`
`158`	`158`	`return tok1 && tok2 && tok1->location.sameline(tok2->location);`
`159`	`159`	`}`
`160`	`160`
`161`		`-static bool isAlternativeBinaryOp(const simplecpp::Token *tok, const std::string &alt)`
	`161`	`+static bool isAlternativeBinaryOp(const simplecpp::Token * const tok, const std::string &alt)`
`162`	`162`	`{`
`163`	`163`	`return (tok->name &&`
`164`	`164`	`tok->str() == alt &&`
`@@ -168,7 +168,7 @@ static bool isAlternativeBinaryOp(const simplecpp::Token *tok, const std::string`
`168`	`168`	`(tok->next->number \|\| tok->next->name \|\| tok->next->op == '('));`
`169`	`169`	`}`
`170`	`170`
`171`		`-static bool isAlternativeUnaryOp(const simplecpp::Token *tok, const std::string &alt)`
	`171`	`+static bool isAlternativeUnaryOp(const simplecpp::Token * const tok, const std::string &alt)`
`172`	`172`	`{`
`173`	`173`	`return ((tok->name && tok->str() == alt) &&`
`174`	`174`	`(!tok->previous \|\| tok->previous->op == '(') &&`
`@@ -622,7 +622,7 @@ static std::string escapeString(const std::string &str)`
`622`	`622`	`return ostr.str();`
`623`	`623`	`}`
`624`	`624`
`625`		`-static void portabilityBackslash(simplecpp::OutputList *outputList, const simplecpp::Location &location)`
	`625`	`+static void portabilityBackslash(simplecpp::OutputList * const outputList, const simplecpp::Location &location)`
`626`	`626`	`{`
`627`	`627`	`if (!outputList)`
`628`	`628`	`return;`
`@@ -799,7 +799,7 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,`
`799`	`799`	`if (ch == '\\') {`
`800`	`800`	`TokenString tmp;`
`801`	`801`	`char tmp_ch = ch;`
`802`		`- while ((stream.good()) && (tmp_ch == '\\' \|\| tmp_ch == ' ' \|\| tmp_ch == '\t')) {`
	`802`	`+ while (stream.good() && (tmp_ch == '\\' \|\| tmp_ch == ' ' \|\| tmp_ch == '\t')) {`
`803`	`803`	`tmp += tmp_ch;`
`804`	`804`	`tmp_ch = stream.readChar();`
`805`	`805`	`}`
`@@ -999,7 +999,7 @@ void simplecpp::TokenList::constFold()`
`999`	`999`	`}`
`1000`	`1000`	`}`
`1001`	`1001`
`1002`		`-static bool isFloatSuffix(const simplecpp::Token *tok)`
	`1002`	`+static bool isFloatSuffix(const simplecpp::Token * const tok)`
`1003`	`1003`	`{`
`1004`	`1004`	`if (!tok \|\| tok->str().size() != 1U)`
`1005`	`1005`	`return false;`
`@@ -1010,7 +1010,7 @@ static bool isFloatSuffix(const simplecpp::Token *tok)`
`1010`	`1010`	`static const std::string AND("and");`
`1011`	`1011`	`static const std::string BITAND("bitand");`
`1012`	`1012`	`static const std::string BITOR("bitor");`
`1013`		`-static bool isAlternativeAndBitandBitor(const simplecpp::Token* tok)`
	`1013`	`+static bool isAlternativeAndBitandBitor(const simplecpp::Token * const tok)`
`1014`	`1014`	`{`
`1015`	`1015`	`return isAlternativeBinaryOp(tok, AND) \|\| isAlternativeBinaryOp(tok, BITAND) \|\| isAlternativeBinaryOp(tok, BITOR);`
`1016`	`1016`	`}`
`@@ -1699,7 +1699,7 @@ namespace simplecpp {`
`1699`	`1699`	`};`
`1700`	`1700`
`1701`	`1701`	`struct invalidDirectiveAsMacroParameter : public Error {`
`1702`		`- invalidDirectiveAsMacroParameter(const Location &loc)`
	`1702`	`+ explicit invalidDirectiveAsMacroParameter(const Location &loc)`
`1703`	`1703`	`: Error(loc, "it is invalid to use a preprocessor directive as macro parameter") {}`
`1704`	`1704`	`};`
`1705`	`1705`
`@@ -2296,7 +2296,7 @@ namespace simplecpp {`
`2296`	`2296`	`* @return token after B`
`2297`	`2297`	`*/`
`2298`	`2298`	`const Token expandHashHash(TokenList &output, const Location &loc, const Token tok, const MacroMap &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens, bool expandResult=true) const {`
`2299`		`- Token *A = output.back();`
	`2299`	`+ Token * const A = output.back();`
`2300`	`2300`	`if (!A)`
`2301`	`2301`	`throw invalidHashHash(tok->location, name(), "Missing first argument");`
`2302`	`2302`	`if (!sameline(tok, tok->next) \|\| !sameline(tok, tok->next->next))`
`@@ -3258,7 +3258,7 @@ static bool getFileId(const std::string &path, FileID &id)`
`3258`	`3258`	`#endif`
`3259`	`3259`	`}`
`3260`	`3260`
`3261`		`-simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens, std::vector<std::string> &filenames, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, FileDataCache cache)`
	`3261`	`+simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens, std::vector<std::string> &filenames, const simplecpp::DUI &dui, simplecpp::OutputList * const outputList, FileDataCache cache)`
`3262`	`3262`	`{`
`3263`	`3263`	`#ifdef SIMPLECPP_WINDOWS`
`3264`	`3264`	`if (dui.clearIncludeCache)`
`@@ -3341,7 +3341,7 @@ simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens,`
`3341`	`3341`	`return cache;`
`3342`	`3342`	`}`
`3343`	`3343`
`3344`		`-static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token &tok1, simplecpp::MacroMap &macros, std::vector<std::string> &files, simplecpp::OutputList outputList)`
	`3344`	`+static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token &tok1, simplecpp::MacroMap &macros, std::vector<std::string> &files, simplecpp::OutputList const outputList)`
`3345`	`3345`	`{`
`3346`	`3346`	`const simplecpp::Token * const tok = tok1;`
`3347`	`3347`	`const simplecpp::MacroMap::const_iterator it = tok->name ? macros.find(tok->str()) : macros.end();`
`@@ -3391,21 +3391,21 @@ static void getLocaltime(struct tm &ltime)`
`3391`	`3391`	`#endif`
`3392`	`3392`	`}`
`3393`	`3393`
`3394`		`-static std::string getDateDefine(const struct tm *timep)`
	`3394`	`+static std::string getDateDefine(const struct tm * const timep)`
`3395`	`3395`	`{`
`3396`	`3396`	`char buf[] = "??? ?? ????";`
`3397`	`3397`	`strftime(buf, sizeof(buf), "%b %d %Y", timep);`
`3398`	`3398`	`return std::string("\"").append(buf).append("\"");`
`3399`	`3399`	`}`
`3400`	`3400`
`3401`		`-static std::string getTimeDefine(const struct tm *timep)`
	`3401`	`+static std::string getTimeDefine(const struct tm * const timep)`
`3402`	`3402`	`{`
`3403`	`3403`	`char buf[] = "??:??:??";`
`3404`	`3404`	`strftime(buf, sizeof(buf), "%H:%M:%S", timep);`
`3405`	`3405`	`return std::string("\"").append(buf).append("\"");`
`3406`	`3406`	`}`
`3407`	`3407`
`3408`		`-void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenList &rawtokens, std::vector<std::string> &files, simplecpp::FileDataCache &cache, const simplecpp::DUI &dui, simplecpp::OutputList outputList, std::list<simplecpp::MacroUsage> macroUsage, std::list<simplecpp::IfCond> *ifCond)`
	`3408`	`+void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenList &rawtokens, std::vector<std::string> &files, simplecpp::FileDataCache &cache, const simplecpp::DUI &dui, simplecpp::OutputList * const outputList, std::list<simplecpp::MacroUsage> * const macroUsage, std::list<simplecpp::IfCond> * const ifCond)`
`3409`	`3409`	`{`
`3410`	`3410`	`#ifdef SIMPLECPP_WINDOWS`
`3411`	`3411`	`if (dui.clearIncludeCache)`
`@@ -3783,6 +3783,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL`
`3783`	`3783`	`std::string header;`
`3784`	`3784`
`3785`	`3785`	`if (systemheader) {`
	`3786`	`+ // NOLINTNEXTLINE(bugprone-assignment-in-selection-statement)`
`3786`	`3787`	`while ((tok = tok->next) && tok->op != '>')`
`3787`	`3788`	`header += tok->str();`
`3788`	`3789`	`if (tok && tok->op == '>')`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ static void assertThrowFailed(int line)`
`86`	`86`	`std::cerr << "exception not thrown" << std::endl;`
`87`	`87`	`}`
`88`	`88`
`89`		`-static void testcase(const std::string &name, void (f)(), int argc, char const *argv)`
	`89`	`+static void testcase(const std::string &name, void (const f)(), int argc, char argv[])`
`90`	`90`	`{`
`91`	`91`	`if (argc == 1) {`
`92`	`92`	`f();`
`@@ -101,7 +101,7 @@ static void testcase(const std::string &name, void (f)(), int argc, char cons`
`101`	`101`
`102`	`102`	`#define TEST_CASE(F) (testcase(#F, F, argc, argv))`
`103`	`103`
`104`		`-static simplecpp::TokenList makeTokenList(const char code[], std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList *outputList=nullptr)`
	`104`	`+static simplecpp::TokenList makeTokenList(const char code[], std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList * const outputList=nullptr)`
`105`	`105`	`{`
`106`	`106`	`switch (USE_INPUT) {`
`107`	`107`	`case Input::Stringstream: {`
`@@ -115,24 +115,24 @@ static simplecpp::TokenList makeTokenList(const char code[], std::size_t size, s`
`115`	`115`	`return simplecpp::TokenList{filenames}; // unreachable - needed for GCC and Visual Studio`
`116`	`116`	`}`
`117`	`117`
`118`		`-static simplecpp::TokenList makeTokenList(const char code[], std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList *outputList=nullptr)`
	`118`	`+static simplecpp::TokenList makeTokenList(const char code[], std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList * const outputList=nullptr)`
`119`	`119`	`{`
`120`	`120`	`return makeTokenList(code, strlen(code), filenames, filename, outputList);`
`121`	`121`	`}`
`122`	`122`
`123`		`-static std::string readfile(const char code[], simplecpp::OutputList *outputList=nullptr)`
	`123`	`+static std::string readfile(const char code[], simplecpp::OutputList * const outputList=nullptr)`
`124`	`124`	`{`
`125`	`125`	`std::vector<std::string> files;`
`126`	`126`	`return makeTokenList(code,files,std::string(),outputList).stringify();`
`127`	`127`	`}`
`128`	`128`
`129`		`-static std::string readfile(const char code[], std::size_t size, simplecpp::OutputList *outputList=nullptr)`
	`129`	`+static std::string readfile(const char code[], std::size_t size, simplecpp::OutputList * const outputList=nullptr)`
`130`	`130`	`{`
`131`	`131`	`std::vector<std::string> files;`
`132`	`132`	`return makeTokenList(code,size,files,std::string(),outputList).stringify();`
`133`	`133`	`}`
`134`	`134`
`135`		`-static std::string preprocess(const char code[], const simplecpp::DUI &dui, simplecpp::OutputList outputList, std::list<simplecpp::MacroUsage> macroUsage = nullptr, std::list<simplecpp::IfCond> *ifCond = nullptr, const std::string &file = std::string())`
	`135`	`+static std::string preprocess(const char code[], const simplecpp::DUI &dui, simplecpp::OutputList * const outputList, std::list<simplecpp::MacroUsage> * const macroUsage = nullptr, std::list<simplecpp::IfCond> * const ifCond = nullptr, const std::string &file = std::string())`
`136`	`136`	`{`
`137`	`137`	`std::vector<std::string> files;`
`138`	`138`	`simplecpp::FileDataCache cache;`
`@@ -160,17 +160,17 @@ static std::string preprocess(const char code[], const simplecpp::DUI &dui)`
`160`	`160`	`return preprocess(code, dui, nullptr);`
`161`	`161`	`}`
`162`	`162`
`163`		`-static std::string preprocess(const char code[], simplecpp::OutputList *outputList)`
	`163`	`+static std::string preprocess(const char code[], simplecpp::OutputList * const outputList)`
`164`	`164`	`{`
`165`	`165`	`return preprocess(code, simplecpp::DUI(), outputList);`
`166`	`166`	`}`
`167`	`167`
`168`		`-static std::string preprocess(const char code[], std::list<simplecpp::IfCond> *ifCond)`
	`168`	`+static std::string preprocess(const char code[], std::list<simplecpp::IfCond> * const ifCond)`
`169`	`169`	`{`
`170`	`170`	`return preprocess(code, simplecpp::DUI(), nullptr, nullptr, ifCond);`
`171`	`171`	`}`
`172`	`172`
`173`		`-static std::string preprocess(const char code[], std::list<simplecpp::MacroUsage> *macroUsage)`
	`173`	`+static std::string preprocess(const char code[], std::list<simplecpp::MacroUsage> * const macroUsage)`
`174`	`174`	`{`
`175`	`175`	`return preprocess(code, simplecpp::DUI(), nullptr, macroUsage);`
`176`	`176`	`}`
`@@ -3960,7 +3960,7 @@ static void leak()`
`3960`	`3960`	`}`
`3961`	`3961`	`}`
`3962`	`3962`
`3963`		`-static void runTests(int argc, char **argv, Input input)`
	`3963`	`+static void runTests(int argc, char *argv[], Input input)`
`3964`	`3964`	`{`
`3965`	`3965`	`USE_INPUT = input;`
`3966`	`3966`
`@@ -4257,7 +4257,7 @@ static void runTests(int argc, char **argv, Input input)`
`4257`	`4257`	`TEST_CASE(leak);`
`4258`	`4258`	`}`
`4259`	`4259`
`4260`		`-int main(int argc, char **argv)`
	`4260`	`+int main(int argc, char *argv[])`
`4261`	`4261`	`{`
`4262`	`4262`	`runTests(argc, argv, Input::Stringstream);`
`4263`	`4263`	`runTests(argc, argv, Input::CharBuffer);`