• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===--- MacroInfo.h - Information about #defined identifiers ---*- C++ -*-===//
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 defines the MacroInfo interface.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_MACROINFO_H
15 #define LLVM_CLANG_MACROINFO_H
16 
17 #include "clang/Lex/Token.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/Support/Allocator.h"
20 #include <cassert>
21 
22 namespace clang {
23   class Preprocessor;
24 
25 /// MacroInfo - Each identifier that is #define'd has an instance of this class
26 /// associated with it, used to implement macro expansion.
27 class MacroInfo {
28   //===--------------------------------------------------------------------===//
29   // State set when the macro is defined.
30 
31   /// Location - This is the place the macro is defined.
32   SourceLocation Location;
33   /// EndLocation - The location of the last token in the macro.
34   SourceLocation EndLocation;
35 
36   /// Arguments - The list of arguments for a function-like macro.  This can be
37   /// empty, for, e.g. "#define X()".  In a C99-style variadic macro, this
38   /// includes the __VA_ARGS__ identifier on the list.
39   IdentifierInfo **ArgumentList;
40   unsigned NumArguments;
41 
42   /// \brief The location at which this macro was either explicitly exported
43   /// from its module or marked as private.
44   ///
45   /// If invalid, this macro has not been explicitly given any visibility.
46   SourceLocation VisibilityLocation;
47 
48   /// ReplacementTokens - This is the list of tokens that the macro is defined
49   /// to.
50   SmallVector<Token, 8> ReplacementTokens;
51 
52   /// \brief Length in characters of the macro definition.
53   mutable unsigned DefinitionLength;
54   mutable bool IsDefinitionLengthCached : 1;
55 
56   /// IsFunctionLike - True if this macro is a function-like macro, false if it
57   /// is an object-like macro.
58   bool IsFunctionLike : 1;
59 
60   /// IsC99Varargs - True if this macro is of the form "#define X(...)" or
61   /// "#define X(Y,Z,...)".  The __VA_ARGS__ token should be replaced with the
62   /// contents of "..." in an invocation.
63   bool IsC99Varargs : 1;
64 
65   /// IsGNUVarargs -  True if this macro is of the form "#define X(a...)".  The
66   /// "a" identifier in the replacement list will be replaced with all arguments
67   /// of the macro starting with the specified one.
68   bool IsGNUVarargs : 1;
69 
70   /// IsBuiltinMacro - True if this is a builtin macro, such as __LINE__, and if
71   /// it has not yet been redefined or undefined.
72   bool IsBuiltinMacro : 1;
73 
74   /// IsFromAST - True if this macro was loaded from an AST file.
75   bool IsFromAST : 1;
76 
77   /// \brief Whether this macro changed after it was loaded from an AST file.
78   bool ChangedAfterLoad : 1;
79 
80 private:
81   //===--------------------------------------------------------------------===//
82   // State that changes as the macro is used.
83 
84   /// IsDisabled - True if we have started an expansion of this macro already.
85   /// This disbles recursive expansion, which would be quite bad for things like
86   /// #define A A.
87   bool IsDisabled : 1;
88 
89   /// IsUsed - True if this macro is either defined in the main file and has
90   /// been used, or if it is not defined in the main file.  This is used to
91   /// emit -Wunused-macros diagnostics.
92   bool IsUsed : 1;
93 
94   /// AllowRedefinitionsWithoutWarning - True if this macro can be redefined
95   /// without emitting a warning.
96   bool IsAllowRedefinitionsWithoutWarning : 1;
97 
98   /// \brief Must warn if the macro is unused at the end of translation unit.
99   bool IsWarnIfUnused : 1;
100 
101   /// \brief Whether the macro has public (when described in a module).
102   bool IsPublic : 1;
103 
~MacroInfo()104    ~MacroInfo() {
105     assert(ArgumentList == 0 && "Didn't call destroy before dtor!");
106   }
107 
108 public:
109   MacroInfo(SourceLocation DefLoc);
110   MacroInfo(const MacroInfo &MI, llvm::BumpPtrAllocator &PPAllocator);
111 
112   /// FreeArgumentList - Free the argument list of the macro, restoring it to a
113   /// state where it can be reused for other devious purposes.
FreeArgumentList()114   void FreeArgumentList() {
115     ArgumentList = 0;
116     NumArguments = 0;
117   }
118 
119   /// Destroy - destroy this MacroInfo object.
Destroy()120   void Destroy() {
121     FreeArgumentList();
122     this->~MacroInfo();
123   }
124 
125   /// getDefinitionLoc - Return the location that the macro was defined at.
126   ///
getDefinitionLoc()127   SourceLocation getDefinitionLoc() const { return Location; }
128 
129   /// setDefinitionEndLoc - Set the location of the last token in the macro.
130   ///
setDefinitionEndLoc(SourceLocation EndLoc)131   void setDefinitionEndLoc(SourceLocation EndLoc) { EndLocation = EndLoc; }
132   /// getDefinitionEndLoc - Return the location of the last token in the macro.
133   ///
getDefinitionEndLoc()134   SourceLocation getDefinitionEndLoc() const { return EndLocation; }
135 
136   /// \brief Get length in characters of the macro definition.
getDefinitionLength(SourceManager & SM)137   unsigned getDefinitionLength(SourceManager &SM) const {
138     if (IsDefinitionLengthCached)
139       return DefinitionLength;
140     return getDefinitionLengthSlow(SM);
141   }
142 
143   /// isIdenticalTo - Return true if the specified macro definition is equal to
144   /// this macro in spelling, arguments, and whitespace.  This is used to emit
145   /// duplicate definition warnings.  This implements the rules in C99 6.10.3.
146   bool isIdenticalTo(const MacroInfo &Other, Preprocessor &PP) const;
147 
148   /// setIsBuiltinMacro - Set or clear the isBuiltinMacro flag.
149   ///
150   void setIsBuiltinMacro(bool Val = true) {
151     IsBuiltinMacro = Val;
152   }
153 
154   /// setIsUsed - Set the value of the IsUsed flag.
155   ///
setIsUsed(bool Val)156   void setIsUsed(bool Val) {
157     IsUsed = Val;
158   }
159 
160   /// setIsAllowRedefinitionsWithoutWarning - Set the value of the
161   /// IsAllowRedefinitionsWithoutWarning flag.
setIsAllowRedefinitionsWithoutWarning(bool Val)162   void setIsAllowRedefinitionsWithoutWarning(bool Val) {
163     IsAllowRedefinitionsWithoutWarning = Val;
164   }
165 
166   /// \brief Set the value of the IsWarnIfUnused flag.
setIsWarnIfUnused(bool val)167   void setIsWarnIfUnused(bool val) {
168     IsWarnIfUnused = val;
169   }
170 
171   /// setArgumentList - Set the specified list of identifiers as the argument
172   /// list for this macro.
setArgumentList(IdentifierInfo * const * List,unsigned NumArgs,llvm::BumpPtrAllocator & PPAllocator)173   void setArgumentList(IdentifierInfo* const *List, unsigned NumArgs,
174                        llvm::BumpPtrAllocator &PPAllocator) {
175     assert(ArgumentList == 0 && NumArguments == 0 &&
176            "Argument list already set!");
177     if (NumArgs == 0) return;
178 
179     NumArguments = NumArgs;
180     ArgumentList = PPAllocator.Allocate<IdentifierInfo*>(NumArgs);
181     for (unsigned i = 0; i != NumArgs; ++i)
182       ArgumentList[i] = List[i];
183   }
184 
185   /// Arguments - The list of arguments for a function-like macro.  This can be
186   /// empty, for, e.g. "#define X()".
187   typedef IdentifierInfo* const *arg_iterator;
arg_empty()188   bool arg_empty() const { return NumArguments == 0; }
arg_begin()189   arg_iterator arg_begin() const { return ArgumentList; }
arg_end()190   arg_iterator arg_end() const { return ArgumentList+NumArguments; }
getNumArgs()191   unsigned getNumArgs() const { return NumArguments; }
192 
193   /// getArgumentNum - Return the argument number of the specified identifier,
194   /// or -1 if the identifier is not a formal argument identifier.
getArgumentNum(IdentifierInfo * Arg)195   int getArgumentNum(IdentifierInfo *Arg) const {
196     for (arg_iterator I = arg_begin(), E = arg_end(); I != E; ++I)
197       if (*I == Arg) return I-arg_begin();
198     return -1;
199   }
200 
201   /// Function/Object-likeness.  Keep track of whether this macro has formal
202   /// parameters.
setIsFunctionLike()203   void setIsFunctionLike() { IsFunctionLike = true; }
isFunctionLike()204   bool isFunctionLike() const { return IsFunctionLike; }
isObjectLike()205   bool isObjectLike() const { return !IsFunctionLike; }
206 
207   /// Varargs querying methods.  This can only be set for function-like macros.
setIsC99Varargs()208   void setIsC99Varargs() { IsC99Varargs = true; }
setIsGNUVarargs()209   void setIsGNUVarargs() { IsGNUVarargs = true; }
isC99Varargs()210   bool isC99Varargs() const { return IsC99Varargs; }
isGNUVarargs()211   bool isGNUVarargs() const { return IsGNUVarargs; }
isVariadic()212   bool isVariadic() const { return IsC99Varargs | IsGNUVarargs; }
213 
214   /// isBuiltinMacro - Return true if this macro is a builtin macro, such as
215   /// __LINE__, which requires processing before expansion.
isBuiltinMacro()216   bool isBuiltinMacro() const { return IsBuiltinMacro; }
217 
218   /// isFromAST - Return true if this macro was loaded from an AST file.
isFromAST()219   bool isFromAST() const { return IsFromAST; }
220 
221   /// setIsFromAST - Set whether this macro was loaded from an AST file.
222   void setIsFromAST(bool FromAST = true) { IsFromAST = FromAST; }
223 
224   /// \brief Determine whether this macro has changed since it was loaded from
225   /// an AST file.
hasChangedAfterLoad()226   bool hasChangedAfterLoad() const { return ChangedAfterLoad; }
227 
228   /// \brief Note whether this macro has changed after it was loaded from an
229   /// AST file.
230   void setChangedAfterLoad(bool CAL = true) { ChangedAfterLoad = CAL; }
231 
232   /// isUsed - Return false if this macro is defined in the main file and has
233   /// not yet been used.
isUsed()234   bool isUsed() const { return IsUsed; }
235 
236   /// isAllowRedefinitionsWithoutWarning - Return true if this macro can be
237   /// redefined without warning.
isAllowRedefinitionsWithoutWarning()238   bool isAllowRedefinitionsWithoutWarning() const {
239     return IsAllowRedefinitionsWithoutWarning;
240   }
241 
242   /// \brief Return true if we should emit a warning if the macro is unused.
isWarnIfUnused()243   bool isWarnIfUnused() const {
244     return IsWarnIfUnused;
245   }
246 
247   /// getNumTokens - Return the number of tokens that this macro expands to.
248   ///
getNumTokens()249   unsigned getNumTokens() const {
250     return ReplacementTokens.size();
251   }
252 
getReplacementToken(unsigned Tok)253   const Token &getReplacementToken(unsigned Tok) const {
254     assert(Tok < ReplacementTokens.size() && "Invalid token #");
255     return ReplacementTokens[Tok];
256   }
257 
258   typedef SmallVector<Token, 8>::const_iterator tokens_iterator;
tokens_begin()259   tokens_iterator tokens_begin() const { return ReplacementTokens.begin(); }
tokens_end()260   tokens_iterator tokens_end() const { return ReplacementTokens.end(); }
tokens_empty()261   bool tokens_empty() const { return ReplacementTokens.empty(); }
262 
263   /// AddTokenToBody - Add the specified token to the replacement text for the
264   /// macro.
AddTokenToBody(const Token & Tok)265   void AddTokenToBody(const Token &Tok) {
266     assert(!IsDefinitionLengthCached &&
267           "Changing replacement tokens after definition length got calculated");
268     ReplacementTokens.push_back(Tok);
269   }
270 
271   /// isEnabled - Return true if this macro is enabled: in other words, that we
272   /// are not currently in an expansion of this macro.
isEnabled()273   bool isEnabled() const { return !IsDisabled; }
274 
EnableMacro()275   void EnableMacro() {
276     assert(IsDisabled && "Cannot enable an already-enabled macro!");
277     IsDisabled = false;
278   }
279 
DisableMacro()280   void DisableMacro() {
281     assert(!IsDisabled && "Cannot disable an already-disabled macro!");
282     IsDisabled = true;
283   }
284 
285   /// \brief Set the export location for this macro.
setVisibility(bool Public,SourceLocation Loc)286   void setVisibility(bool Public, SourceLocation Loc) {
287     VisibilityLocation = Loc;
288     IsPublic = Public;
289   }
290 
291   /// \brief Determine whether this macro is part of the public API of its
292   /// module.
isPublic()293   bool isPublic() const { return IsPublic; }
294 
295   /// \brief Determine the location where this macro was explicitly made
296   /// public or private within its module.
getVisibilityLocation()297   SourceLocation getVisibilityLocation() { return VisibilityLocation; }
298 
299 private:
300   unsigned getDefinitionLengthSlow(SourceManager &SM) const;
301 };
302 
303 }  // end namespace clang
304 
305 #endif
306