contrib/llvm/tools/clang/lib/Lex/MacroInfo.cpp

   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
  18 MacroInfo::MacroInfo(SourceLocation DefLoc)
  19   : Location(DefLoc),
  20     ArgumentList(nullptr),
  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     UsedForHeaderGuard(false) {
  34 }
  35
  36 unsigned MacroInfo::getDefinitionLengthSlow(SourceManager &SM) const {
  37   assert(!IsDefinitionLengthCached);
  38   IsDefinitionLengthCached = true;
  39
  40   if (ReplacementTokens.empty())
  41     return (DefinitionLength = 0);
  42
  43   const Token &firstToken = ReplacementTokens.front();
  44   const Token &lastToken = ReplacementTokens.back();
  45   SourceLocation macroStart = firstToken.getLocation();
  46   SourceLocation macroEnd = lastToken.getLocation();
  47   assert(macroStart.isValid() && macroEnd.isValid());
  48   assert((macroStart.isFileID() || firstToken.is(tok::comment)) &&
  49          "Macro defined in macro?");
  50   assert((macroEnd.isFileID() || lastToken.is(tok::comment)) &&
  51          "Macro defined in macro?");
  52   std::pair<FileID, unsigned>
  53       startInfo = SM.getDecomposedExpansionLoc(macroStart);
  54   std::pair<FileID, unsigned>
  55       endInfo = SM.getDecomposedExpansionLoc(macroEnd);
  56   assert(startInfo.first == endInfo.first &&
  57          "Macro definition spanning multiple FileIDs ?");
  58   assert(startInfo.second <= endInfo.second);
  59   DefinitionLength = endInfo.second - startInfo.second;
  60   DefinitionLength += lastToken.getLength();
  61
  62   return DefinitionLength;
  63 }
  64
  65 /// \brief Return true if the specified macro definition is equal to
  66 /// this macro in spelling, arguments, and whitespace.
  67 ///
  68 /// \param Syntactically if true, the macro definitions can be identical even
  69 /// if they use different identifiers for the function macro parameters.
  70 /// Otherwise the comparison is lexical and this implements the rules in
  71 /// C99 6.10.3.
  72 bool MacroInfo::isIdenticalTo(const MacroInfo &Other, Preprocessor &PP,
  73                               bool Syntactically) const {
  74   bool Lexically = !Syntactically;
  75
  76   // Check # tokens in replacement, number of args, and various flags all match.
  77   if (ReplacementTokens.size() != Other.ReplacementTokens.size() ||
  78       getNumArgs() != Other.getNumArgs() ||
  79       isFunctionLike() != Other.isFunctionLike() ||
  80       isC99Varargs() != Other.isC99Varargs() ||
  81       isGNUVarargs() != Other.isGNUVarargs())
  82     return false;
  83
  84   if (Lexically) {
  85     // Check arguments.
  86     for (arg_iterator I = arg_begin(), OI = Other.arg_begin(), E = arg_end();
  87          I != E; ++I, ++OI)
  88       if (*I != *OI) return false;
  89   }
  90
  91   // Check all the tokens.
  92   for (unsigned i = 0, e = ReplacementTokens.size(); i != e; ++i) {
  93     const Token &A = ReplacementTokens[i];
  94     const Token &B = Other.ReplacementTokens[i];
  95     if (A.getKind() != B.getKind())
  96       return false;
  97
  98     // If this isn't the first first token, check that the whitespace and
  99     // start-of-line characteristics match.
 100     if (i != 0 &&
 101         (A.isAtStartOfLine() != B.isAtStartOfLine() ||
 102          A.hasLeadingSpace() != B.hasLeadingSpace()))
 103       return false;
 104
 105     // If this is an identifier, it is easy.
 106     if (A.getIdentifierInfo() || B.getIdentifierInfo()) {
 107       if (A.getIdentifierInfo() == B.getIdentifierInfo())
 108         continue;
 109       if (Lexically)
 110         return false;
 111       // With syntactic equivalence the parameter names can be different as long
 112       // as they are used in the same place.
 113       int AArgNum = getArgumentNum(A.getIdentifierInfo());
 114       if (AArgNum == -1)
 115         return false;
 116       if (AArgNum != Other.getArgumentNum(B.getIdentifierInfo()))
 117         return false;
 118       continue;
 119     }
 120
 121     // Otherwise, check the spelling.
 122     if (PP.getSpelling(A) != PP.getSpelling(B))
 123       return false;
 124   }
 125
 126   return true;
 127 }
 128
 129 void MacroInfo::dump() const {
 130   llvm::raw_ostream &Out = llvm::errs();
 131
 132   // FIXME: Dump locations.
 133   Out << "MacroInfo " << this;
 134   if (IsBuiltinMacro) Out << " builtin";
 135   if (IsDisabled) Out << " disabled";
 136   if (IsUsed) Out << " used";
 137   if (IsAllowRedefinitionsWithoutWarning)
 138     Out << " allow_redefinitions_without_warning";
 139   if (IsWarnIfUnused) Out << " warn_if_unused";
 140   if (FromASTFile) Out << " imported";
 141   if (UsedForHeaderGuard) Out << " header_guard";
 142
 143   Out << "\n    #define <macro>";
 144   if (IsFunctionLike) {
 145     Out << "(";
 146     for (unsigned I = 0; I != NumArguments; ++I) {
 147       if (I) Out << ", ";
 148       Out << ArgumentList[I]->getName();
 149     }
 150     if (IsC99Varargs || IsGNUVarargs) {
 151       if (NumArguments && IsC99Varargs) Out << ", ";
 152       Out << "...";
 153     }
 154     Out << ")";
 155   }
 156
 157   for (const Token &Tok : ReplacementTokens) {
 158     Out << " ";
 159     if (const char *Punc = tok::getPunctuatorSpelling(Tok.getKind()))
 160       Out << Punc;
 161     else if (const char *Kwd = tok::getKeywordSpelling(Tok.getKind()))
 162       Out << Kwd;
 163     else if (Tok.is(tok::identifier))
 164       Out << Tok.getIdentifierInfo()->getName();
 165     else if (Tok.isLiteral() && Tok.getLiteralData())
 166       Out << StringRef(Tok.getLiteralData(), Tok.getLength());
 167     else
 168       Out << Tok.getName();
 169   }
 170 }
 171
 172 MacroDirective::DefInfo MacroDirective::getDefinition() {
 173   MacroDirective *MD = this;
 174   SourceLocation UndefLoc;
 175   Optional<bool> isPublic;
 176   for (; MD; MD = MD->getPrevious()) {
 177     if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD))
 178       return DefInfo(DefMD, UndefLoc,
 179                      !isPublic.hasValue() || isPublic.getValue());
 180
 181     if (UndefMacroDirective *UndefMD = dyn_cast<UndefMacroDirective>(MD)) {
 182       UndefLoc = UndefMD->getLocation();
 183       continue;
 184     }
 185
 186     VisibilityMacroDirective *VisMD = cast<VisibilityMacroDirective>(MD);
 187     if (!isPublic.hasValue())
 188       isPublic = VisMD->isPublic();
 189   }
 190
 191   return DefInfo(nullptr, UndefLoc,
 192                  !isPublic.hasValue() || isPublic.getValue());
 193 }
 194
 195 const MacroDirective::DefInfo
 196 MacroDirective::findDirectiveAtLoc(SourceLocation L, SourceManager &SM) const {
 197   assert(L.isValid() && "SourceLocation is invalid.");
 198   for (DefInfo Def = getDefinition(); Def; Def = Def.getPreviousDefinition()) {
 199     if (Def.getLocation().isInvalid() ||  // For macros defined on the command line.
 200         SM.isBeforeInTranslationUnit(Def.getLocation(), L))
 201       return (!Def.isUndefined() ||
 202               SM.isBeforeInTranslationUnit(L, Def.getUndefLocation()))
 203                   ? Def : DefInfo();
 204   }
 205   return DefInfo();
 206 }
 207
 208 void MacroDirective::dump() const {
 209   llvm::raw_ostream &Out = llvm::errs();
 210
 211   switch (getKind()) {
 212   case MD_Define: Out << "DefMacroDirective"; break;
 213   case MD_Undefine: Out << "UndefMacroDirective"; break;
 214   case MD_Visibility: Out << "VisibilityMacroDirective"; break;
 215   }
 216   Out << " " << this;
 217   // FIXME: Dump SourceLocation.
 218   if (auto *Prev = getPrevious())
 219     Out << " prev " << Prev;
 220   if (IsFromPCH) Out << " from_pch";
 221   if (IsImported) Out << " imported";
 222   if (IsAmbiguous) Out << " ambiguous";
 223
 224   if (IsPublic)
 225     Out << " public";
 226   else if (isa<VisibilityMacroDirective>(this))
 227     Out << " private";
 228
 229   if (auto *DMD = dyn_cast<DefMacroDirective>(this)) {
 230     if (auto *Info = DMD->getInfo()) {
 231       Out << "\n  ";
 232       Info->dump();
 233     }
 234   }
 235   Out << "\n";
 236 }