mitigated misc-const-correctness clang-tidy warnings

firewave · firewave · commit cc90221633b1 · 2026-07-11T10:39:34.000+02:00
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;
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;
@@ -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);
 }
@@ -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))
@@ -3136,7 +3136,7 @@ simplecpp::FileDataCache &simplecpp::FileDataCache::operator=(simplecpp::FileDat
 
 static bool getFileId(const std::string &path, FileID &id);
 
-std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::tryload(FileDataCache::name_map_type::iterator &name_it, const simplecpp::DUI &dui, std::vector<std::string> &filenames, simplecpp::OutputList *outputList)
+std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::tryload(FileDataCache::name_map_type::iterator &name_it, const simplecpp::DUI &dui, std::vector<std::string> &filenames, simplecpp::OutputList * outputList)
 {
     const std::string &path = name_it->first;
     FileID fileId;
@@ -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)
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
`@@ -26,7 +26,7 @@ static bool isDir(const std::string& path)`
`26`	`26`	`return (file_stat.st_mode & S_IFMT) == S_IFDIR;`
`27`	`27`	`}`
`28`	`28`
`29`		`-int main(int argc, char **argv)`
	`29`	`+int main(int argc, char *argv[])`
`30`	`30`	`{`
`31`	`31`	`bool error = false;`
`32`	`32`	`const char *filename = nullptr;`
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;`
`@@ -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`	`}`
`@@ -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))`
`@@ -3136,7 +3136,7 @@ simplecpp::FileDataCache &simplecpp::FileDataCache::operator=(simplecpp::FileDat`
`3136`	`3136`
`3137`	`3137`	`static bool getFileId(const std::string &path, FileID &id);`
`3138`	`3138`
`3139`		`-std::pair<simplecpp::FileData , bool> simplecpp::FileDataCache::tryload(FileDataCache::name_map_type::iterator &name_it, const simplecpp::DUI &dui, std::vector<std::string> &filenames, simplecpp::OutputList outputList)`
	`3139`	`+std::pair<simplecpp::FileData , bool> simplecpp::FileDataCache::tryload(FileDataCache::name_map_type::iterator &name_it, const simplecpp::DUI &dui, std::vector<std::string> &filenames, simplecpp::OutputList outputList)`
`3140`	`3140`	`{`
`3141`	`3141`	`const std::string &path = name_it->first;`
`3142`	`3142`	`FileID fileId;`
`@@ -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)`
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);`