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