1 //===--- MacroInfo.cpp - Information about #defined identifiers -----------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the MacroInfo interface.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Lex/MacroInfo.h"
15 #include "clang/Lex/Preprocessor.h"
16 using namespace clang;
17
MacroInfo(SourceLocation DefLoc)18 MacroInfo::MacroInfo(SourceLocation DefLoc)
19 : Location(DefLoc),
20 ArgumentList(0),
21 NumArguments(0),
22 IsDefinitionLengthCached(false),
23 IsFunctionLike(false),
24 IsC99Varargs(false),
25 IsGNUVarargs(false),
26 IsBuiltinMacro(false),
27 HasCommaPasting(false),
28 IsDisabled(false),
29 IsUsed(false),
30 IsAllowRedefinitionsWithoutWarning(false),
31 IsWarnIfUnused(false),
32 FromASTFile(false) {
33 }
34
getDefinitionLengthSlow(SourceManager & SM) const35 unsigned MacroInfo::getDefinitionLengthSlow(SourceManager &SM) const {
36 assert(!IsDefinitionLengthCached);
37 IsDefinitionLengthCached = true;
38
39 if (ReplacementTokens.empty())
40 return (DefinitionLength = 0);
41
42 const Token &firstToken = ReplacementTokens.front();
43 const Token &lastToken = ReplacementTokens.back();
44 SourceLocation macroStart = firstToken.getLocation();
45 SourceLocation macroEnd = lastToken.getLocation();
46 assert(macroStart.isValid() && macroEnd.isValid());
47 assert((macroStart.isFileID() || firstToken.is(tok::comment)) &&
48 "Macro defined in macro?");
49 assert((macroEnd.isFileID() || lastToken.is(tok::comment)) &&
50 "Macro defined in macro?");
51 std::pair<FileID, unsigned>
52 startInfo = SM.getDecomposedExpansionLoc(macroStart);
53 std::pair<FileID, unsigned>
54 endInfo = SM.getDecomposedExpansionLoc(macroEnd);
55 assert(startInfo.first == endInfo.first &&
56 "Macro definition spanning multiple FileIDs ?");
57 assert(startInfo.second <= endInfo.second);
58 DefinitionLength = endInfo.second - startInfo.second;
59 DefinitionLength += lastToken.getLength();
60
61 return DefinitionLength;
62 }
63
64 /// \brief Return true if the specified macro definition is equal to
65 /// this macro in spelling, arguments, and whitespace.
66 ///
67 /// \param Syntactically if true, the macro definitions can be identical even
68 /// if they use different identifiers for the function macro parameters.
69 /// Otherwise the comparison is lexical and this implements the rules in
70 /// C99 6.10.3.
isIdenticalTo(const MacroInfo & Other,Preprocessor & PP,bool Syntactically) const71 bool MacroInfo::isIdenticalTo(const MacroInfo &Other, Preprocessor &PP,
72 bool Syntactically) const {
73 bool Lexically = !Syntactically;
74
75 // Check # tokens in replacement, number of args, and various flags all match.
76 if (ReplacementTokens.size() != Other.ReplacementTokens.size() ||
77 getNumArgs() != Other.getNumArgs() ||
78 isFunctionLike() != Other.isFunctionLike() ||
79 isC99Varargs() != Other.isC99Varargs() ||
80 isGNUVarargs() != Other.isGNUVarargs())
81 return false;
82
83 if (Lexically) {
84 // Check arguments.
85 for (arg_iterator I = arg_begin(), OI = Other.arg_begin(), E = arg_end();
86 I != E; ++I, ++OI)
87 if (*I != *OI) return false;
88 }
89
90 // Check all the tokens.
91 for (unsigned i = 0, e = ReplacementTokens.size(); i != e; ++i) {
92 const Token &A = ReplacementTokens[i];
93 const Token &B = Other.ReplacementTokens[i];
94 if (A.getKind() != B.getKind())
95 return false;
96
97 // If this isn't the first first token, check that the whitespace and
98 // start-of-line characteristics match.
99 if (i != 0 &&
100 (A.isAtStartOfLine() != B.isAtStartOfLine() ||
101 A.hasLeadingSpace() != B.hasLeadingSpace()))
102 return false;
103
104 // If this is an identifier, it is easy.
105 if (A.getIdentifierInfo() || B.getIdentifierInfo()) {
106 if (A.getIdentifierInfo() == B.getIdentifierInfo())
107 continue;
108 if (Lexically)
109 return false;
110 // With syntactic equivalence the parameter names can be different as long
111 // as they are used in the same place.
112 int AArgNum = getArgumentNum(A.getIdentifierInfo());
113 if (AArgNum == -1)
114 return false;
115 if (AArgNum != Other.getArgumentNum(B.getIdentifierInfo()))
116 return false;
117 continue;
118 }
119
120 // Otherwise, check the spelling.
121 if (PP.getSpelling(A) != PP.getSpelling(B))
122 return false;
123 }
124
125 return true;
126 }
127
getDefinition(bool AllowHidden)128 MacroDirective::DefInfo MacroDirective::getDefinition(bool AllowHidden) {
129 MacroDirective *MD = this;
130 SourceLocation UndefLoc;
131 Optional<bool> isPublic;
132 for (; MD; MD = MD->getPrevious()) {
133 if (!AllowHidden && MD->isHidden())
134 continue;
135
136 if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD))
137 return DefInfo(DefMD, UndefLoc,
138 !isPublic.hasValue() || isPublic.getValue());
139
140 if (UndefMacroDirective *UndefMD = dyn_cast<UndefMacroDirective>(MD)) {
141 UndefLoc = UndefMD->getLocation();
142 continue;
143 }
144
145 VisibilityMacroDirective *VisMD = cast<VisibilityMacroDirective>(MD);
146 if (!isPublic.hasValue())
147 isPublic = VisMD->isPublic();
148 }
149
150 return DefInfo();
151 }
152
153 const MacroDirective::DefInfo
findDirectiveAtLoc(SourceLocation L,SourceManager & SM) const154 MacroDirective::findDirectiveAtLoc(SourceLocation L, SourceManager &SM) const {
155 assert(L.isValid() && "SourceLocation is invalid.");
156 for (DefInfo Def = getDefinition(); Def; Def = Def.getPreviousDefinition()) {
157 if (Def.getLocation().isInvalid() || // For macros defined on the command line.
158 SM.isBeforeInTranslationUnit(Def.getLocation(), L))
159 return (!Def.isUndefined() ||
160 SM.isBeforeInTranslationUnit(L, Def.getUndefLocation()))
161 ? Def : DefInfo();
162 }
163 return DefInfo();
164 }
165