mitigated misc-const-correctness clang-tidy warnings

firewave · firewave · commit 9422e4d83ee6 · 2026-07-14T15:54:28.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))
@@ -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
@@ -90,7 +90,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();
@@ -105,7 +105,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: {
@@ -119,24 +119,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[], std::size_t size, 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[], std::size_t size, 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;
@@ -169,7 +169,7 @@ 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);
 }
@@ -179,12 +179,12 @@ static std::string preprocess(const char code[], std::size_t size, simplecpp::Ou
     return preprocess(code, size, 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);
 }
@@ -4052,7 +4052,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;
 
@@ -4360,7 +4360,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))`
`@@ -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
`@@ -90,7 +90,7 @@ static void assertThrowFailed(int line)`
`90`	`90`	`std::cerr << "exception not thrown" << std::endl;`
`91`	`91`	`}`
`92`	`92`
`93`		`-static void testcase(const std::string &name, void (f)(), int argc, char const *argv)`
	`93`	`+static void testcase(const std::string &name, void (const f)(), int argc, char argv[])`
`94`	`94`	`{`
`95`	`95`	`if (argc == 1) {`
`96`	`96`	`f();`
`@@ -105,7 +105,7 @@ static void testcase(const std::string &name, void (f)(), int argc, char cons`
`105`	`105`
`106`	`106`	`#define TEST_CASE(F) (testcase(#F, F, argc, argv))`
`107`	`107`
`108`		`-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)`
	`108`	`+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)`
`109`	`109`	`{`
`110`	`110`	`switch (USE_INPUT) {`
`111`	`111`	`case Input::Stringstream: {`
`@@ -119,24 +119,24 @@ static simplecpp::TokenList makeTokenList(const char code[], std::size_t size, s`
`119`	`119`	`return simplecpp::TokenList{filenames}; // unreachable - needed for GCC and Visual Studio`
`120`	`120`	`}`
`121`	`121`
`122`		`-static simplecpp::TokenList makeTokenList(const char code[], std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList *outputList=nullptr)`
	`122`	`+static simplecpp::TokenList makeTokenList(const char code[], std::vector<std::string> &filenames, const std::string &filename=std::string(), simplecpp::OutputList * const outputList=nullptr)`
`123`	`123`	`{`
`124`	`124`	`return makeTokenList(code, strlen(code), filenames, filename, outputList);`
`125`	`125`	`}`
`126`	`126`
`127`		`-static std::string readfile(const char code[], simplecpp::OutputList *outputList=nullptr)`
	`127`	`+static std::string readfile(const char code[], simplecpp::OutputList * const outputList=nullptr)`
`128`	`128`	`{`
`129`	`129`	`std::vector<std::string> files;`
`130`	`130`	`return makeTokenList(code,files,std::string(),outputList).stringify();`
`131`	`131`	`}`
`132`	`132`
`133`		`-static std::string readfile(const char code[], std::size_t size, simplecpp::OutputList *outputList=nullptr)`
	`133`	`+static std::string readfile(const char code[], std::size_t size, simplecpp::OutputList * const outputList=nullptr)`
`134`	`134`	`{`
`135`	`135`	`std::vector<std::string> files;`
`136`	`136`	`return makeTokenList(code,size,files,std::string(),outputList).stringify();`
`137`	`137`	`}`
`138`	`138`
`139`		`-static std::string preprocess(const char code[], std::size_t size, 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())`
	`139`	`+static std::string preprocess(const char code[], std::size_t size, 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())`
`140`	`140`	`{`
`141`	`141`	`std::vector<std::string> files;`
`142`	`142`	`simplecpp::FileDataCache cache;`
`@@ -169,7 +169,7 @@ static std::string preprocess(const char code[], const simplecpp::DUI &dui)`
`169`	`169`	`return preprocess(code, dui, nullptr);`
`170`	`170`	`}`
`171`	`171`
`172`		`-static std::string preprocess(const char code[], simplecpp::OutputList *outputList)`
	`172`	`+static std::string preprocess(const char code[], simplecpp::OutputList * const outputList)`
`173`	`173`	`{`
`174`	`174`	`return preprocess(code, simplecpp::DUI(), outputList);`
`175`	`175`	`}`
`@@ -179,12 +179,12 @@ static std::string preprocess(const char code[], std::size_t size, simplecpp::Ou`
`179`	`179`	`return preprocess(code, size, simplecpp::DUI(), outputList);`
`180`	`180`	`}`
`181`	`181`
`182`		`-static std::string preprocess(const char code[], std::list<simplecpp::IfCond> *ifCond)`
	`182`	`+static std::string preprocess(const char code[], std::list<simplecpp::IfCond> * const ifCond)`
`183`	`183`	`{`
`184`	`184`	`return preprocess(code, simplecpp::DUI(), nullptr, nullptr, ifCond);`
`185`	`185`	`}`
`186`	`186`
`187`		`-static std::string preprocess(const char code[], std::list<simplecpp::MacroUsage> *macroUsage)`
	`187`	`+static std::string preprocess(const char code[], std::list<simplecpp::MacroUsage> * const macroUsage)`
`188`	`188`	`{`
`189`	`189`	`return preprocess(code, simplecpp::DUI(), nullptr, macroUsage);`
`190`	`190`	`}`
`@@ -4052,7 +4052,7 @@ static void leak()`
`4052`	`4052`	`}`
`4053`	`4053`	`}`
`4054`	`4054`
`4055`		`-static void runTests(int argc, char **argv, Input input)`
	`4055`	`+static void runTests(int argc, char *argv[], Input input)`
`4056`	`4056`	`{`
`4057`	`4057`	`USE_INPUT = input;`
`4058`	`4058`
`@@ -4360,7 +4360,7 @@ static void runTests(int argc, char **argv, Input input)`
`4360`	`4360`	`TEST_CASE(leak);`
`4361`	`4361`	`}`
`4362`	`4362`
`4363`		`-int main(int argc, char **argv)`
	`4363`	`+int main(int argc, char *argv[])`
`4364`	`4364`	`{`
`4365`	`4365`	`runTests(argc, argv, Input::Stringstream);`
`4366`	`4366`	`runTests(argc, argv, Input::CharBuffer);`