}
/// \brief Hook called whenever a macro \#undef is seen.
- /// \param Token The active Token
- /// \param MD A MacroDefinition for the named macro.
- /// \param Undef New MacroDirective if the macro was defined, null otherwise.
///
/// MD is released immediately following this callback.
virtual void MacroUndefined(const Token &MacroNameTok,
- const MacroDefinition &MD,
- const MacroDirective *Undef) {
+ const MacroDefinition &MD) {
}
/// \brief Hook called whenever the 'defined' operator is seen.
Second->MacroExpands(MacroNameTok, MD, Range, Args);
}
- void MacroDefined(const Token &MacroNameTok,
- const MacroDirective *MD) override {
+ void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD) override {
First->MacroDefined(MacroNameTok, MD);
Second->MacroDefined(MacroNameTok, MD);
}
void MacroUndefined(const Token &MacroNameTok,
- const MacroDefinition &MD,
- const MacroDirective *Undef) override {
- First->MacroUndefined(MacroNameTok, MD, Undef);
- Second->MacroUndefined(MacroNameTok, MD, Undef);
+ const MacroDefinition &MD) override {
+ First->MacroUndefined(MacroNameTok, MD);
+ Second->MacroUndefined(MacroNameTok, MD);
}
void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
// Okay, we have a valid identifier to undef.
auto *II = MacroNameTok.getIdentifierInfo();
auto MD = getMacroDefinition(II);
- UndefMacroDirective *Undef = nullptr;
-
- // If the macro is not defined, this is a noop undef.
- if (const MacroInfo *MI = MD.getMacroInfo()) {
- if (!MI->isUsed() && MI->isWarnIfUnused())
- Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);
-
- if (MI->isWarnIfUnused())
- WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
-
- Undef = AllocateUndefMacroDirective(MacroNameTok.getLocation());
- }
// If the callbacks want to know, tell them about the macro #undef.
// Note: no matter if the macro was defined or not.
if (Callbacks)
- Callbacks->MacroUndefined(MacroNameTok, MD, Undef);
+ Callbacks->MacroUndefined(MacroNameTok, MD);
+
+ // If the macro is not defined, this is a noop undef, just return.
+ const MacroInfo *MI = MD.getMacroInfo();
+ if (!MI)
+ return;
+
+ if (!MI->isUsed() && MI->isWarnIfUnused())
+ Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);
+
+ if (MI->isWarnIfUnused())
+ WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
- if (Undef)
- appendMacroDirective(II, Undef);
+ appendMacroDirective(MacroNameTok.getIdentifierInfo(),
+ AllocateUndefMacroDirective(MacroNameTok.getLocation()));
}
//===----------------------------------------------------------------------===//
namespace {
struct MacroAction {
- enum Kind { kExpansion, kDefinition, kUnDefinition};
-
SourceLocation Loc;
std::string Name;
- unsigned MAKind : 3;
-
- MacroAction(SourceLocation Loc, StringRef Name, unsigned K)
- : Loc(Loc), Name(Name), MAKind(K) { }
-
- bool isExpansion() const { return MAKind == kExpansion; }
- bool isDefinition() const { return MAKind & kDefinition; }
- bool isUnDefinition() const { return MAKind & kUnDefinition; }
+ bool isDefinition; // if false, it is expansion.
+
+ MacroAction(SourceLocation Loc, StringRef Name, bool isDefinition)
+ : Loc(Loc), Name(Name), isDefinition(isDefinition) { }
};
class MacroTracker : public PPCallbacks {
const MacroDirective *MD) override {
Macros.push_back(MacroAction(MD->getLocation(),
MacroNameTok.getIdentifierInfo()->getName(),
- MacroAction::kDefinition));
- }
- void MacroUndefined(const Token &MacroNameTok,
- const MacroDefinition &MD,
- const MacroDirective *UD) override {
- Macros.push_back(
- MacroAction(UD ? UD->getLocation() : SourceLocation(),
- MacroNameTok.getIdentifierInfo()->getName(),
- UD ? MacroAction::kDefinition | MacroAction::kUnDefinition
- : MacroAction::kUnDefinition));
+ true));
}
void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
SourceRange Range, const MacroArgs *Args) override {
Macros.push_back(MacroAction(MacroNameTok.getLocation(),
MacroNameTok.getIdentifierInfo()->getName(),
- MacroAction::kExpansion));
+ false));
}
};
TEST_F(SourceManagerTest, isBeforeInTranslationUnitWithMacroInInclude) {
const char *header =
- "#define MACRO_IN_INCLUDE 0\n"
- "#define MACRO_DEFINED\n"
- "#undef MACRO_DEFINED\n"
- "#undef MACRO_UNDEFINED\n";
+ "#define MACRO_IN_INCLUDE 0\n";
const char *main =
"#define M(x) x\n"
// Make sure we got the tokens that we expected.
ASSERT_EQ(0U, toks.size());
- ASSERT_EQ(15U, Macros.size());
+ ASSERT_EQ(9U, Macros.size());
// #define M(x) x
- ASSERT_TRUE(Macros[0].isDefinition());
+ ASSERT_TRUE(Macros[0].isDefinition);
ASSERT_EQ("M", Macros[0].Name);
// #define INC "/test-header.h"
- ASSERT_TRUE(Macros[1].isDefinition());
+ ASSERT_TRUE(Macros[1].isDefinition);
ASSERT_EQ("INC", Macros[1].Name);
// M expansion in #include M(INC)
- ASSERT_FALSE(Macros[2].isDefinition());
+ ASSERT_FALSE(Macros[2].isDefinition);
ASSERT_EQ("M", Macros[2].Name);
// INC expansion in #include M(INC)
- ASSERT_TRUE(Macros[3].isExpansion());
+ ASSERT_FALSE(Macros[3].isDefinition);
ASSERT_EQ("INC", Macros[3].Name);
// #define MACRO_IN_INCLUDE 0
- ASSERT_TRUE(Macros[4].isDefinition());
+ ASSERT_TRUE(Macros[4].isDefinition);
ASSERT_EQ("MACRO_IN_INCLUDE", Macros[4].Name);
- // #define MACRO_DEFINED
- ASSERT_TRUE(Macros[5].isDefinition());
- ASSERT_FALSE(Macros[5].isUnDefinition());
- ASSERT_EQ("MACRO_DEFINED", Macros[5].Name);
- // #undef MACRO_DEFINED
- ASSERT_TRUE(Macros[6].isDefinition());
- ASSERT_TRUE(Macros[6].isUnDefinition());
- ASSERT_EQ("MACRO_DEFINED", Macros[6].Name);
- // #undef MACRO_UNDEFINED
- ASSERT_FALSE(Macros[7].isDefinition());
- ASSERT_TRUE(Macros[7].isUnDefinition());
- ASSERT_EQ("MACRO_UNDEFINED", Macros[7].Name);
// #define INC2 </test-header.h>
- ASSERT_TRUE(Macros[8].isDefinition());
- ASSERT_EQ("INC2", Macros[8].Name);
+ ASSERT_TRUE(Macros[5].isDefinition);
+ ASSERT_EQ("INC2", Macros[5].Name);
// M expansion in #include M(INC2)
- ASSERT_FALSE(Macros[9].isDefinition());
- ASSERT_EQ("M", Macros[9].Name);
+ ASSERT_FALSE(Macros[6].isDefinition);
+ ASSERT_EQ("M", Macros[6].Name);
// INC2 expansion in #include M(INC2)
- ASSERT_TRUE(Macros[10].isExpansion());
- ASSERT_EQ("INC2", Macros[10].Name);
+ ASSERT_FALSE(Macros[7].isDefinition);
+ ASSERT_EQ("INC2", Macros[7].Name);
// #define MACRO_IN_INCLUDE 0
- ASSERT_TRUE(Macros[11].isDefinition());
- ASSERT_EQ("MACRO_IN_INCLUDE", Macros[11].Name);
+ ASSERT_TRUE(Macros[8].isDefinition);
+ ASSERT_EQ("MACRO_IN_INCLUDE", Macros[8].Name);
// The INC expansion in #include M(INC) comes before the first
// MACRO_IN_INCLUDE definition of the included file.
// The INC2 expansion in #include M(INC2) comes before the second
// MACRO_IN_INCLUDE definition of the included file.
- EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[10].Loc, Macros[11].Loc));
+ EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[7].Loc, Macros[8].Loc));
}
#endif