| //===--- MacroInfo.h - Information about #defined identifiers ---*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file defines the MacroInfo interface. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_CLANG_MACROINFO_H |
| #define LLVM_CLANG_MACROINFO_H |
| |
| #include "clang/Lex/Token.h" |
| #include "llvm/ADT/SmallVector.h" |
| #include "llvm/Support/Allocator.h" |
| #include <cassert> |
| |
| namespace clang { |
| class Preprocessor; |
| |
| /// MacroInfo - Each identifier that is #define'd has an instance of this class |
| /// associated with it, used to implement macro expansion. |
| class MacroInfo { |
| //===--------------------------------------------------------------------===// |
| // State set when the macro is defined. |
| |
| /// Location - This is the place the macro is defined. |
| SourceLocation Location; |
| /// EndLocation - The location of the last token in the macro. |
| SourceLocation EndLocation; |
| |
| /// Arguments - The list of arguments for a function-like macro. This can be |
| /// empty, for, e.g. "#define X()". In a C99-style variadic macro, this |
| /// includes the __VA_ARGS__ identifier on the list. |
| IdentifierInfo **ArgumentList; |
| unsigned NumArguments; |
| |
| /// \brief The location at which this macro was either explicitly exported |
| /// from its module or marked as private. |
| /// |
| /// If invalid, this macro has not been explicitly given any visibility. |
| SourceLocation VisibilityLocation; |
| |
| /// ReplacementTokens - This is the list of tokens that the macro is defined |
| /// to. |
| SmallVector<Token, 8> ReplacementTokens; |
| |
| /// \brief Length in characters of the macro definition. |
| mutable unsigned DefinitionLength; |
| mutable bool IsDefinitionLengthCached : 1; |
| |
| /// IsFunctionLike - True if this macro is a function-like macro, false if it |
| /// is an object-like macro. |
| bool IsFunctionLike : 1; |
| |
| /// IsC99Varargs - True if this macro is of the form "#define X(...)" or |
| /// "#define X(Y,Z,...)". The __VA_ARGS__ token should be replaced with the |
| /// contents of "..." in an invocation. |
| bool IsC99Varargs : 1; |
| |
| /// IsGNUVarargs - True if this macro is of the form "#define X(a...)". The |
| /// "a" identifier in the replacement list will be replaced with all arguments |
| /// of the macro starting with the specified one. |
| bool IsGNUVarargs : 1; |
| |
| /// IsBuiltinMacro - True if this is a builtin macro, such as __LINE__, and if |
| /// it has not yet been redefined or undefined. |
| bool IsBuiltinMacro : 1; |
| |
| /// IsFromAST - True if this macro was loaded from an AST file. |
| bool IsFromAST : 1; |
| |
| /// \brief Whether this macro changed after it was loaded from an AST file. |
| bool ChangedAfterLoad : 1; |
| |
| private: |
| //===--------------------------------------------------------------------===// |
| // State that changes as the macro is used. |
| |
| /// IsDisabled - True if we have started an expansion of this macro already. |
| /// This disbles recursive expansion, which would be quite bad for things like |
| /// #define A A. |
| bool IsDisabled : 1; |
| |
| /// IsUsed - True if this macro is either defined in the main file and has |
| /// been used, or if it is not defined in the main file. This is used to |
| /// emit -Wunused-macros diagnostics. |
| bool IsUsed : 1; |
| |
| /// AllowRedefinitionsWithoutWarning - True if this macro can be redefined |
| /// without emitting a warning. |
| bool IsAllowRedefinitionsWithoutWarning : 1; |
| |
| /// \brief Must warn if the macro is unused at the end of translation unit. |
| bool IsWarnIfUnused : 1; |
| |
| /// \brief Whether the macro has public (when described in a module). |
| bool IsPublic : 1; |
| |
| ~MacroInfo() { |
| assert(ArgumentList == 0 && "Didn't call destroy before dtor!"); |
| } |
| |
| public: |
| MacroInfo(SourceLocation DefLoc); |
| MacroInfo(const MacroInfo &MI, llvm::BumpPtrAllocator &PPAllocator); |
| |
| /// FreeArgumentList - Free the argument list of the macro, restoring it to a |
| /// state where it can be reused for other devious purposes. |
| void FreeArgumentList() { |
| ArgumentList = 0; |
| NumArguments = 0; |
| } |
| |
| /// Destroy - destroy this MacroInfo object. |
| void Destroy() { |
| FreeArgumentList(); |
| this->~MacroInfo(); |
| } |
| |
| /// getDefinitionLoc - Return the location that the macro was defined at. |
| /// |
| SourceLocation getDefinitionLoc() const { return Location; } |
| |
| /// setDefinitionEndLoc - Set the location of the last token in the macro. |
| /// |
| void setDefinitionEndLoc(SourceLocation EndLoc) { EndLocation = EndLoc; } |
| /// getDefinitionEndLoc - Return the location of the last token in the macro. |
| /// |
| SourceLocation getDefinitionEndLoc() const { return EndLocation; } |
| |
| /// \brief Get length in characters of the macro definition. |
| unsigned getDefinitionLength(SourceManager &SM) const { |
| if (IsDefinitionLengthCached) |
| return DefinitionLength; |
| return getDefinitionLengthSlow(SM); |
| } |
| |
| /// isIdenticalTo - Return true if the specified macro definition is equal to |
| /// this macro in spelling, arguments, and whitespace. This is used to emit |
| /// duplicate definition warnings. This implements the rules in C99 6.10.3. |
| bool isIdenticalTo(const MacroInfo &Other, Preprocessor &PP) const; |
| |
| /// setIsBuiltinMacro - Set or clear the isBuiltinMacro flag. |
| /// |
| void setIsBuiltinMacro(bool Val = true) { |
| IsBuiltinMacro = Val; |
| } |
| |
| /// setIsUsed - Set the value of the IsUsed flag. |
| /// |
| void setIsUsed(bool Val) { |
| IsUsed = Val; |
| } |
| |
| /// setIsAllowRedefinitionsWithoutWarning - Set the value of the |
| /// IsAllowRedefinitionsWithoutWarning flag. |
| void setIsAllowRedefinitionsWithoutWarning(bool Val) { |
| IsAllowRedefinitionsWithoutWarning = Val; |
| } |
| |
| /// \brief Set the value of the IsWarnIfUnused flag. |
| void setIsWarnIfUnused(bool val) { |
| IsWarnIfUnused = val; |
| } |
| |
| /// setArgumentList - Set the specified list of identifiers as the argument |
| /// list for this macro. |
| void setArgumentList(IdentifierInfo* const *List, unsigned NumArgs, |
| llvm::BumpPtrAllocator &PPAllocator) { |
| assert(ArgumentList == 0 && NumArguments == 0 && |
| "Argument list already set!"); |
| if (NumArgs == 0) return; |
| |
| NumArguments = NumArgs; |
| ArgumentList = PPAllocator.Allocate<IdentifierInfo*>(NumArgs); |
| for (unsigned i = 0; i != NumArgs; ++i) |
| ArgumentList[i] = List[i]; |
| } |
| |
| /// Arguments - The list of arguments for a function-like macro. This can be |
| /// empty, for, e.g. "#define X()". |
| typedef IdentifierInfo* const *arg_iterator; |
| bool arg_empty() const { return NumArguments == 0; } |
| arg_iterator arg_begin() const { return ArgumentList; } |
| arg_iterator arg_end() const { return ArgumentList+NumArguments; } |
| unsigned getNumArgs() const { return NumArguments; } |
| |
| /// getArgumentNum - Return the argument number of the specified identifier, |
| /// or -1 if the identifier is not a formal argument identifier. |
| int getArgumentNum(IdentifierInfo *Arg) const { |
| for (arg_iterator I = arg_begin(), E = arg_end(); I != E; ++I) |
| if (*I == Arg) return I-arg_begin(); |
| return -1; |
| } |
| |
| /// Function/Object-likeness. Keep track of whether this macro has formal |
| /// parameters. |
| void setIsFunctionLike() { IsFunctionLike = true; } |
| bool isFunctionLike() const { return IsFunctionLike; } |
| bool isObjectLike() const { return !IsFunctionLike; } |
| |
| /// Varargs querying methods. This can only be set for function-like macros. |
| void setIsC99Varargs() { IsC99Varargs = true; } |
| void setIsGNUVarargs() { IsGNUVarargs = true; } |
| bool isC99Varargs() const { return IsC99Varargs; } |
| bool isGNUVarargs() const { return IsGNUVarargs; } |
| bool isVariadic() const { return IsC99Varargs | IsGNUVarargs; } |
| |
| /// isBuiltinMacro - Return true if this macro is a builtin macro, such as |
| /// __LINE__, which requires processing before expansion. |
| bool isBuiltinMacro() const { return IsBuiltinMacro; } |
| |
| /// isFromAST - Return true if this macro was loaded from an AST file. |
| bool isFromAST() const { return IsFromAST; } |
| |
| /// setIsFromAST - Set whether this macro was loaded from an AST file. |
| void setIsFromAST(bool FromAST = true) { IsFromAST = FromAST; } |
| |
| /// \brief Determine whether this macro has changed since it was loaded from |
| /// an AST file. |
| bool hasChangedAfterLoad() const { return ChangedAfterLoad; } |
| |
| /// \brief Note whether this macro has changed after it was loaded from an |
| /// AST file. |
| void setChangedAfterLoad(bool CAL = true) { ChangedAfterLoad = CAL; } |
| |
| /// isUsed - Return false if this macro is defined in the main file and has |
| /// not yet been used. |
| bool isUsed() const { return IsUsed; } |
| |
| /// isAllowRedefinitionsWithoutWarning - Return true if this macro can be |
| /// redefined without warning. |
| bool isAllowRedefinitionsWithoutWarning() const { |
| return IsAllowRedefinitionsWithoutWarning; |
| } |
| |
| /// \brief Return true if we should emit a warning if the macro is unused. |
| bool isWarnIfUnused() const { |
| return IsWarnIfUnused; |
| } |
| |
| /// getNumTokens - Return the number of tokens that this macro expands to. |
| /// |
| unsigned getNumTokens() const { |
| return ReplacementTokens.size(); |
| } |
| |
| const Token &getReplacementToken(unsigned Tok) const { |
| assert(Tok < ReplacementTokens.size() && "Invalid token #"); |
| return ReplacementTokens[Tok]; |
| } |
| |
| typedef SmallVector<Token, 8>::const_iterator tokens_iterator; |
| tokens_iterator tokens_begin() const { return ReplacementTokens.begin(); } |
| tokens_iterator tokens_end() const { return ReplacementTokens.end(); } |
| bool tokens_empty() const { return ReplacementTokens.empty(); } |
| |
| /// AddTokenToBody - Add the specified token to the replacement text for the |
| /// macro. |
| void AddTokenToBody(const Token &Tok) { |
| assert(!IsDefinitionLengthCached && |
| "Changing replacement tokens after definition length got calculated"); |
| ReplacementTokens.push_back(Tok); |
| } |
| |
| /// isEnabled - Return true if this macro is enabled: in other words, that we |
| /// are not currently in an expansion of this macro. |
| bool isEnabled() const { return !IsDisabled; } |
| |
| void EnableMacro() { |
| assert(IsDisabled && "Cannot enable an already-enabled macro!"); |
| IsDisabled = false; |
| } |
| |
| void DisableMacro() { |
| assert(!IsDisabled && "Cannot disable an already-disabled macro!"); |
| IsDisabled = true; |
| } |
| |
| /// \brief Set the export location for this macro. |
| void setVisibility(bool Public, SourceLocation Loc) { |
| VisibilityLocation = Loc; |
| IsPublic = Public; |
| } |
| |
| /// \brief Determine whether this macro is part of the public API of its |
| /// module. |
| bool isPublic() const { return IsPublic; } |
| |
| /// \brief Determine the location where this macro was explicitly made |
| /// public or private within its module. |
| SourceLocation getVisibilityLocation() { return VisibilityLocation; } |
| |
| private: |
| unsigned getDefinitionLengthSlow(SourceManager &SM) const; |
| }; |
| |
| } // end namespace clang |
| |
| #endif |