mitigated misc-const-correctness clang-tidy warnings

firewave · firewave · commit 34dad93734d5 · 2026-05-31T21:16:12.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
@@ -150,12 +150,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 &&
@@ -165,7 +165,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 == '(') &&
@@ -619,7 +619,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;
@@ -1013,7 +1013,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;
@@ -1024,7 +1024,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);
 }
@@ -2306,7 +2306,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))
@@ -3090,7 +3090,7 @@ static std::string openHeader(std::ifstream &f, const simplecpp::DUI &dui, const
     return "";
 }
 
-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 * const outputList)
 {
     const std::string &path = name_it->first;
     FileID fileId;
@@ -3202,7 +3202,7 @@ bool simplecpp::FileDataCache::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)
@@ -3285,7 +3285,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();
@@ -3325,21 +3325,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);
 }
@@ -3868,7 +3868,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;
 
@@ -4159,7 +4159,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
`@@ -150,12 +150,12 @@ static bool endsWith(const std::string &s, const std::string &e)`
`150`	`150`	`return (s.size() >= e.size()) && std::equal(e.rbegin(), e.rend(), s.rbegin());`
`151`	`151`	`}`
`152`	`152`
`153`		`-static bool sameline(const simplecpp::Token tok1, const simplecpp::Token tok2)`
	`153`	`+static bool sameline(const simplecpp::Token * const tok1, const simplecpp::Token * const tok2)`
`154`	`154`	`{`
`155`	`155`	`return tok1 && tok2 && tok1->location.sameline(tok2->location);`
`156`	`156`	`}`
`157`	`157`
`158`		`-static bool isAlternativeBinaryOp(const simplecpp::Token *tok, const std::string &alt)`
	`158`	`+static bool isAlternativeBinaryOp(const simplecpp::Token * const tok, const std::string &alt)`
`159`	`159`	`{`
`160`	`160`	`return (tok->name &&`
`161`	`161`	`tok->str() == alt &&`
`@@ -165,7 +165,7 @@ static bool isAlternativeBinaryOp(const simplecpp::Token *tok, const std::string`
`165`	`165`	`(tok->next->number \|\| tok->next->name \|\| tok->next->op == '('));`
`166`	`166`	`}`
`167`	`167`
`168`		`-static bool isAlternativeUnaryOp(const simplecpp::Token *tok, const std::string &alt)`
	`168`	`+static bool isAlternativeUnaryOp(const simplecpp::Token * const tok, const std::string &alt)`
`169`	`169`	`{`
`170`	`170`	`return ((tok->name && tok->str() == alt) &&`
`171`	`171`	`(!tok->previous \|\| tok->previous->op == '(') &&`
`@@ -619,7 +619,7 @@ static std::string escapeString(const std::string &str)`
`619`	`619`	`return ostr.str();`
`620`	`620`	`}`
`621`	`621`
`622`		`-static void portabilityBackslash(simplecpp::OutputList *outputList, const simplecpp::Location &location)`
	`622`	`+static void portabilityBackslash(simplecpp::OutputList * const outputList, const simplecpp::Location &location)`
`623`	`623`	`{`
`624`	`624`	`if (!outputList)`
`625`	`625`	`return;`
`@@ -1013,7 +1013,7 @@ void simplecpp::TokenList::constFold()`
`1013`	`1013`	`}`
`1014`	`1014`	`}`
`1015`	`1015`
`1016`		`-static bool isFloatSuffix(const simplecpp::Token *tok)`
	`1016`	`+static bool isFloatSuffix(const simplecpp::Token * const tok)`
`1017`	`1017`	`{`
`1018`	`1018`	`if (!tok \|\| tok->str().size() != 1U)`
`1019`	`1019`	`return false;`
`@@ -1024,7 +1024,7 @@ static bool isFloatSuffix(const simplecpp::Token *tok)`
`1024`	`1024`	`static const std::string AND("and");`
`1025`	`1025`	`static const std::string BITAND("bitand");`
`1026`	`1026`	`static const std::string BITOR("bitor");`
`1027`		`-static bool isAlternativeAndBitandBitor(const simplecpp::Token* tok)`
	`1027`	`+static bool isAlternativeAndBitandBitor(const simplecpp::Token * const tok)`
`1028`	`1028`	`{`
`1029`	`1029`	`return isAlternativeBinaryOp(tok, AND) \|\| isAlternativeBinaryOp(tok, BITAND) \|\| isAlternativeBinaryOp(tok, BITOR);`
`1030`	`1030`	`}`
`@@ -2306,7 +2306,7 @@ namespace simplecpp {`
`2306`	`2306`	`* @return token after B`
`2307`	`2307`	`*/`
`2308`	`2308`	`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 {`
`2309`		`- Token *A = output.back();`
	`2309`	`+ Token * const A = output.back();`
`2310`	`2310`	`if (!A)`
`2311`	`2311`	`throw invalidHashHash(tok->location, name(), "Missing first argument");`
`2312`	`2312`	`if (!sameline(tok, tok->next) \|\| !sameline(tok, tok->next->next))`
`@@ -3090,7 +3090,7 @@ static std::string openHeader(std::ifstream &f, const simplecpp::DUI &dui, const`
`3090`	`3090`	`return "";`
`3091`	`3091`	`}`
`3092`	`3092`
`3093`		`-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)`
	`3093`	`+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 const outputList)`
`3094`	`3094`	`{`
`3095`	`3095`	`const std::string &path = name_it->first;`
`3096`	`3096`	`FileID fileId;`
`@@ -3202,7 +3202,7 @@ bool simplecpp::FileDataCache::getFileId(const std::string &path, FileID &id)`
`3202`	`3202`	`#endif`
`3203`	`3203`	`}`
`3204`	`3204`
`3205`		`-simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens, std::vector<std::string> &filenames, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, FileDataCache cache)`
	`3205`	`+simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens, std::vector<std::string> &filenames, const simplecpp::DUI &dui, simplecpp::OutputList * const outputList, FileDataCache cache)`
`3206`	`3206`	`{`
`3207`	`3207`	`#ifdef SIMPLECPP_WINDOWS`
`3208`	`3208`	`if (dui.clearIncludeCache)`
`@@ -3285,7 +3285,7 @@ simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens,`
`3285`	`3285`	`return cache;`
`3286`	`3286`	`}`
`3287`	`3287`
`3288`		`-static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token &tok1, simplecpp::MacroMap &macros, std::vector<std::string> &files, simplecpp::OutputList outputList)`
	`3288`	`+static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token &tok1, simplecpp::MacroMap &macros, std::vector<std::string> &files, simplecpp::OutputList const outputList)`
`3289`	`3289`	`{`
`3290`	`3290`	`const simplecpp::Token * const tok = tok1;`
`3291`	`3291`	`const simplecpp::MacroMap::const_iterator it = tok->name ? macros.find(tok->str()) : macros.end();`
`@@ -3325,21 +3325,21 @@ static void getLocaltime(struct tm &ltime)`
`3325`	`3325`	`#endif`
`3326`	`3326`	`}`
`3327`	`3327`
`3328`		`-static std::string getDateDefine(const struct tm *timep)`
	`3328`	`+static std::string getDateDefine(const struct tm * const timep)`
`3329`	`3329`	`{`
`3330`	`3330`	`char buf[] = "??? ?? ????";`
`3331`	`3331`	`strftime(buf, sizeof(buf), "%b %d %Y", timep);`
`3332`	`3332`	`return std::string("\"").append(buf).append("\"");`
`3333`	`3333`	`}`
`3334`	`3334`
`3335`		`-static std::string getTimeDefine(const struct tm *timep)`
	`3335`	`+static std::string getTimeDefine(const struct tm * const timep)`
`3336`	`3336`	`{`
`3337`	`3337`	`char buf[] = "??:??:??";`
`3338`	`3338`	`strftime(buf, sizeof(buf), "%H:%M:%S", timep);`
`3339`	`3339`	`return std::string("\"").append(buf).append("\"");`
`3340`	`3340`	`}`
`3341`	`3341`
`3342`		`-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)`
	`3342`	`+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)`
`3343`	`3343`	`{`
`3344`	`3344`	`#ifdef SIMPLECPP_WINDOWS`
`3345`	`3345`	`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`	`}`
`@@ -3868,7 +3868,7 @@ static void leak()`
`3868`	`3868`	`}`
`3869`	`3869`	`}`
`3870`	`3870`
`3871`		`-static void runTests(int argc, char **argv, Input input)`
	`3871`	`+static void runTests(int argc, char *argv[], Input input)`
`3872`	`3872`	`{`
`3873`	`3873`	`USE_INPUT = input;`
`3874`	`3874`
`@@ -4159,7 +4159,7 @@ static void runTests(int argc, char **argv, Input input)`
`4159`	`4159`	`TEST_CASE(leak);`
`4160`	`4160`	`}`
`4161`	`4161`
`4162`		`-int main(int argc, char **argv)`
	`4162`	`+int main(int argc, char *argv[])`
`4163`	`4163`	`{`
`4164`	`4164`	`runTests(argc, argv, Input::Stringstream);`
`4165`	`4165`	`runTests(argc, argv, Input::CharBuffer);`