From a5ca9c6141186a6c14c795dc6ea8a8b6d8ce2f2e Mon Sep 17 00:00:00 2001 From: Jay Beavers Date: Mon, 16 Nov 2026 15:49:01 -0800 Subject: [PATCH 1/2] Report the usages of a macro that is undefined or redefined preprocess() built the macro usage list from the macros still defined when preprocessing ended, so the usages of a macro were lost after #undef, and after a redefinition the usages of the first definition were lost. An #ifdef before the #undef was reported against the later definition. The usages are now reported when the definition goes away. --- simplecpp.cpp | 54 ++++++++++++++++++++++++++++++++------------------- test.cpp | 47 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 81 insertions(+), 20 deletions(-) diff --git a/simplecpp.cpp b/simplecpp.cpp index 36daf92a..f8da23b5 100644 --- a/simplecpp.cpp +++ b/simplecpp.cpp @@ -4188,6 +4188,27 @@ static std::string getTimeDefine(const struct tm *timep) return std::string("\"").append(buf).append("\""); } +/** Report the usages of a macro. This is done when its definition goes away, so that #undef and redefinition do not lose them. */ +static void addMacroUsage(const simplecpp::Macro ¯o, std::map> &maybeUsedMacros, std::list *macroUsage) +{ + if (!macroUsage) + return; + std::list usage = macro.usage(); + const std::map>::iterator maybeUsed = maybeUsedMacros.find(macro.name()); + if (maybeUsed != maybeUsedMacros.end()) { + usage.insert(usage.end(), maybeUsed->second.begin(), maybeUsed->second.end()); + maybeUsedMacros.erase(maybeUsed); + } + for (std::list::iterator usageIt = usage.begin(); usageIt != usage.end(); ++usageIt) { + simplecpp::MacroUsage mu(macro.valueDefinedInCode()); + mu.macroName = macro.name(); + mu.macroLocation = macro.defineLocation(); + mu.useLocation = usageIt->location; + mu.arg = std::move(usageIt->arg); + macroUsage->emplace_back(std::move(mu)); + } +} + void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenList &rawtokens, std::vector &files, simplecpp::FileDataCache &cache, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, std::list *macroUsage, std::list *ifCond) { #ifdef SIMPLECPP_WINDOWS @@ -4395,10 +4416,12 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL const Macro ¯o = Macro(rawtok->previous, files); if (dui.undefined.find(macro.name()) == dui.undefined.end()) { const MacroMap::iterator it = macros.find(macro.name()); - if (it == macros.end()) + if (it == macros.end()) { macros.insert(std::pair(macro.name(), macro)); - else + } else { + addMacroUsage(it->second, maybeUsedMacros, macroUsage); it->second = macro; + } } } catch (const std::runtime_error &err) { if (outputList) { @@ -4687,8 +4710,13 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL const Token *tok = rawtok->next; while (sameline(rawtok,tok) && tok->comment) tok = tok->next; - if (sameline(rawtok, tok)) - macros.erase(tok->str()); + if (sameline(rawtok, tok)) { + const MacroMap::iterator it = macros.find(tok->str()); + if (it != macros.end()) { + addMacroUsage(it->second, maybeUsedMacros, macroUsage); + macros.erase(it); + } + } } } else if (ifstates.top() == True && rawtok->str() == PRAGMA && rawtok->next && rawtok->next->str() == ONCE && sameline(rawtok,rawtok->next)) { pragmaOnce.insert(rawtokens.file(rawtok->location)); @@ -4740,22 +4768,8 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL } } - if (macroUsage) { - for (simplecpp::MacroMap::const_iterator macroIt = macros.begin(); macroIt != macros.end(); ++macroIt) { - const Macro ¯o = macroIt->second; - std::list usage = macro.usage(); - const std::list& temp = maybeUsedMacros[macro.name()]; - usage.insert(usage.end(), temp.begin(), temp.end()); - for (std::list::iterator usageIt = usage.begin(); usageIt != usage.end(); ++usageIt) { - MacroUsage mu(macro.valueDefinedInCode()); - mu.macroName = macro.name(); - mu.macroLocation = macro.defineLocation(); - mu.useLocation = usageIt->location; - mu.arg = std::move(usageIt->arg); - macroUsage->emplace_back(std::move(mu)); - } - } - } + for (simplecpp::MacroMap::const_iterator macroIt = macros.begin(); macroIt != macros.end(); ++macroIt) + addMacroUsage(macroIt->second, maybeUsedMacros, macroUsage); } void simplecpp::cleanup(FileDataCache &cache) diff --git a/test.cpp b/test.cpp index f100175f..ceecbb7d 100644 --- a/test.cpp +++ b/test.cpp @@ -5770,6 +5770,50 @@ static void macroUsage() } } +static void macroUsageUndef() +{ + const char code[] = "#define A 1\n" + "A\n" + "#undef A\n" + "A\n"; + std::list macroUsage; + ASSERT_EQUALS("1@A(2:1) A(4:1)", expandedTokens(code, simplecpp::DUI(), ¯oUsage)); + ASSERT_EQUALS("A 1:9 use 2:1\n", toString(macroUsage)); + + // the argument of an integer constant macro is kept + ASSERT_EQUALS("UINT32_C use 2:1: [5]\n", macroUsageArg("#define UINT32_C(x) x\nUINT32_C(5)\n#undef UINT32_C\n")); +} + +static void macroUsageRedefine() +{ + const char code[] = "#define A 1\n" + "A\n" + "#undef A\n" + "#define A 2\n" + "A\n" + "#define B 3\n" + "B\n" + "#define B 4\n" + "B\n"; + std::list macroUsage; + ASSERT_EQUALS("1@A(2:1) 2@A(5:1) 3@B(7:1) 4@B(9:1)", expandedTokens(code, simplecpp::DUI(), ¯oUsage)); + ASSERT_EQUALS("A 1:9 use 2:1\nA 4:9 use 5:1\nB 6:9 use 7:1\nB 8:9 use 9:1\n", toString(macroUsage)); +} + +static void macroUsageUndefIfdef() +{ + const char code[] = "#define A\n" + "#ifdef A\n" + "#endif\n" + "#undef A\n" + "#define A\n" + "#ifdef A\n" + "#endif\n"; + std::list macroUsage; + ASSERT_EQUALS("", expandedTokens(code, simplecpp::DUI(), ¯oUsage)); + ASSERT_EQUALS("A 1:9 use 2:8\nA 5:9 use 6:8\n", toString(macroUsage)); +} + static void isAbsolutePath() { #ifdef _WIN32 ASSERT_EQUALS(true, simplecpp::isAbsolutePath("C:\\foo\\bar")); @@ -6194,6 +6238,9 @@ static void runTests(int argc, char **argv, Input input) TEST_CASE(ifCond); TEST_CASE(macroUsage); + TEST_CASE(macroUsageUndef); + TEST_CASE(macroUsageRedefine); + TEST_CASE(macroUsageUndefIfdef); TEST_CASE(fuzz_crash); From 5797017faf776d9ec3a23df755fba83a438c6aca Mon Sep 17 00:00:00 2001 From: Jay Beavers Date: Thu, 19 Nov 2026 10:02:03 -0800 Subject: [PATCH 2/2] Report no macro usages when preprocessing fails The usages of a macro that is undefined or redefined were added to the caller's list right away, so an error later in the file left that list partly filled, where before it stayed empty. Keep them in a local list and hand it over only when preprocessing succeeds. --- simplecpp.cpp | 13 +++++++++---- test.cpp | 14 ++++++++++++++ 2 files changed, 23 insertions(+), 4 deletions(-) diff --git a/simplecpp.cpp b/simplecpp.cpp index f8da23b5..f7339bd9 100644 --- a/simplecpp.cpp +++ b/simplecpp.cpp @@ -4352,6 +4352,8 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL } std::map> maybeUsedMacros; + // usages of macros that are undefined or redefined, handed over only when preprocessing succeeds + std::list pendingUsage; for (const Token *rawtok = nullptr; rawtok || !includetokenstack.empty();) { if (rawtok == nullptr) { @@ -4419,7 +4421,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL if (it == macros.end()) { macros.insert(std::pair(macro.name(), macro)); } else { - addMacroUsage(it->second, maybeUsedMacros, macroUsage); + addMacroUsage(it->second, maybeUsedMacros, macroUsage ? &pendingUsage : nullptr); it->second = macro; } } @@ -4713,7 +4715,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL if (sameline(rawtok, tok)) { const MacroMap::iterator it = macros.find(tok->str()); if (it != macros.end()) { - addMacroUsage(it->second, maybeUsedMacros, macroUsage); + addMacroUsage(it->second, maybeUsedMacros, macroUsage ? &pendingUsage : nullptr); macros.erase(it); } } @@ -4768,8 +4770,11 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL } } - for (simplecpp::MacroMap::const_iterator macroIt = macros.begin(); macroIt != macros.end(); ++macroIt) - addMacroUsage(macroIt->second, maybeUsedMacros, macroUsage); + if (macroUsage) { + macroUsage->splice(macroUsage->end(), pendingUsage); + for (simplecpp::MacroMap::const_iterator macroIt = macros.begin(); macroIt != macros.end(); ++macroIt) + addMacroUsage(macroIt->second, maybeUsedMacros, macroUsage); + } } void simplecpp::cleanup(FileDataCache &cache) diff --git a/test.cpp b/test.cpp index ceecbb7d..45da650a 100644 --- a/test.cpp +++ b/test.cpp @@ -5784,6 +5784,19 @@ static void macroUsageUndef() ASSERT_EQUALS("UINT32_C use 2:1: [5]\n", macroUsageArg("#define UINT32_C(x) x\nUINT32_C(5)\n#undef UINT32_C\n")); } +static void macroUsageUndefError() +{ + // no usages are reported when preprocessing fails + const char code[] = "#define A 1\n" + "A\n" + "#undef A\n" + "#error stop\n"; + std::list macroUsage; + simplecpp::OutputList outputList; + preprocess(code, simplecpp::DUI(), &outputList, ¯oUsage); + ASSERT_EQUALS("", toString(macroUsage)); +} + static void macroUsageRedefine() { const char code[] = "#define A 1\n" @@ -6239,6 +6252,7 @@ static void runTests(int argc, char **argv, Input input) TEST_CASE(ifCond); TEST_CASE(macroUsage); TEST_CASE(macroUsageUndef); + TEST_CASE(macroUsageUndefError); TEST_CASE(macroUsageRedefine); TEST_CASE(macroUsageUndefIfdef);