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) : Location(DefLoc) {
  19   IsFunctionLike = false;
  20   IsC99Varargs = false;
  21   IsGNUVarargs = false;
  22   IsBuiltinMacro = false;
  23   IsFromAST = false;
  24   ChangedAfterLoad = false;
  25   IsDisabled = false;
  26   IsUsed = false;
  27   IsAllowRedefinitionsWithoutWarning = false;
  28   IsWarnIfUnused = false;
  29   IsDefinitionLengthCached = false;
  30   IsPublic = true;
  31
  32   ArgumentList = 0;
  33   NumArguments = 0;
  34 }
  35
  36 MacroInfo::MacroInfo(const MacroInfo &MI, llvm::BumpPtrAllocator &PPAllocator) {
  37   Location = MI.Location;
  38   EndLocation = MI.EndLocation;
  39   ReplacementTokens = MI.ReplacementTokens;
  40   IsFunctionLike = MI.IsFunctionLike;
  41   IsC99Varargs = MI.IsC99Varargs;
  42   IsGNUVarargs = MI.IsGNUVarargs;
  43   IsBuiltinMacro = MI.IsBuiltinMacro;
  44   IsFromAST = MI.IsFromAST;
  45   ChangedAfterLoad = MI.ChangedAfterLoad;
  46   IsDisabled = MI.IsDisabled;
  47   IsUsed = MI.IsUsed;
  48   IsAllowRedefinitionsWithoutWarning = MI.IsAllowRedefinitionsWithoutWarning;
  49   IsWarnIfUnused = MI.IsWarnIfUnused;
  50   IsDefinitionLengthCached = MI.IsDefinitionLengthCached;
  51   DefinitionLength = MI.DefinitionLength;
  52   IsPublic = MI.IsPublic;
  53
  54   ArgumentList = 0;
  55   NumArguments = 0;
  56   setArgumentList(MI.ArgumentList, MI.NumArguments, PPAllocator);
  57 }
  58
  59 unsigned MacroInfo::getDefinitionLengthSlow(SourceManager &SM) const {
  60   assert(!IsDefinitionLengthCached);
  61   IsDefinitionLengthCached = true;
  62
  63   if (ReplacementTokens.empty())
  64     return (DefinitionLength = 0);
  65
  66   const Token &firstToken = ReplacementTokens.front();
  67   const Token &lastToken = ReplacementTokens.back();
  68   SourceLocation macroStart = firstToken.getLocation();
  69   SourceLocation macroEnd = lastToken.getLocation();
  70   assert(macroStart.isValid() && macroEnd.isValid());
  71   assert((macroStart.isFileID() || firstToken.is(tok::comment)) &&
  72          "Macro defined in macro?");
  73   assert((macroEnd.isFileID() || lastToken.is(tok::comment)) &&
  74          "Macro defined in macro?");
  75   std::pair<FileID, unsigned>
  76       startInfo = SM.getDecomposedExpansionLoc(macroStart);
  77   std::pair<FileID, unsigned>
  78       endInfo = SM.getDecomposedExpansionLoc(macroEnd);
  79   assert(startInfo.first == endInfo.first &&
  80          "Macro definition spanning multiple FileIDs ?");
  81   assert(startInfo.second <= endInfo.second);
  82   DefinitionLength = endInfo.second - startInfo.second;
  83   DefinitionLength += lastToken.getLength();
  84
  85   return DefinitionLength;
  86 }
  87
  88 /// isIdenticalTo - Return true if the specified macro definition is equal to
  89 /// this macro in spelling, arguments, and whitespace.  This is used to emit
  90 /// duplicate definition warnings.  This implements the rules in C99 6.10.3.
  91 ///
  92 bool MacroInfo::isIdenticalTo(const MacroInfo &Other, Preprocessor &PP) const {
  93   // Check # tokens in replacement, number of args, and various flags all match.
  94   if (ReplacementTokens.size() != Other.ReplacementTokens.size() ||
  95       getNumArgs() != Other.getNumArgs() ||
  96       isFunctionLike() != Other.isFunctionLike() ||
  97       isC99Varargs() != Other.isC99Varargs() ||
  98       isGNUVarargs() != Other.isGNUVarargs())
  99     return false;
 100
 101   // Check arguments.
 102   for (arg_iterator I = arg_begin(), OI = Other.arg_begin(), E = arg_end();
 103        I != E; ++I, ++OI)
 104     if (*I != *OI) return false;
 105
 106   // Check all the tokens.
 107   for (unsigned i = 0, e = ReplacementTokens.size(); i != e; ++i) {
 108     const Token &A = ReplacementTokens[i];
 109     const Token &B = Other.ReplacementTokens[i];
 110     if (A.getKind() != B.getKind())
 111       return false;
 112
 113     // If this isn't the first first token, check that the whitespace and
 114     // start-of-line characteristics match.
 115     if (i != 0 &&
 116         (A.isAtStartOfLine() != B.isAtStartOfLine() ||
 117          A.hasLeadingSpace() != B.hasLeadingSpace()))
 118       return false;
 119
 120     // If this is an identifier, it is easy.
 121     if (A.getIdentifierInfo() || B.getIdentifierInfo()) {
 122       if (A.getIdentifierInfo() != B.getIdentifierInfo())
 123         return false;
 124       continue;
 125     }
 126
 127     // Otherwise, check the spelling.
 128     if (PP.getSpelling(A) != PP.getSpelling(B))
 129       return false;
 130   }
 131
 132   return true;
 133 }