1 //===- SourceLocation.cpp - Compact identifier for Source Files -----------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines accessor methods for the FullSourceLoc class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/Basic/SourceLocation.h" 14 #include "clang/Basic/LLVM.h" 15 #include "clang/Basic/PrettyStackTrace.h" 16 #include "clang/Basic/SourceManager.h" 17 #include "llvm/ADT/DenseMapInfo.h" 18 #include "llvm/ADT/FoldingSet.h" 19 #include "llvm/ADT/StringRef.h" 20 #include "llvm/Support/Compiler.h" 21 #include "llvm/Support/MemoryBuffer.h" 22 #include "llvm/Support/raw_ostream.h" 23 #include <cassert> 24 #include <string> 25 #include <utility> 26 27 using namespace clang; 28 29 //===----------------------------------------------------------------------===// 30 // PrettyStackTraceLoc 31 //===----------------------------------------------------------------------===// 32 33 void PrettyStackTraceLoc::print(raw_ostream &OS) const { 34 if (Loc.isValid()) { 35 Loc.print(OS, SM); 36 OS << ": "; 37 } 38 OS << Message << '\n'; 39 } 40 41 //===----------------------------------------------------------------------===// 42 // SourceLocation 43 //===----------------------------------------------------------------------===// 44 45 static_assert(std::is_trivially_destructible_v<SourceLocation>, 46 "SourceLocation must be trivially destructible because it is " 47 "used in unions"); 48 49 static_assert(std::is_trivially_destructible_v<SourceRange>, 50 "SourceRange must be trivially destructible because it is " 51 "used in unions"); 52 53 unsigned SourceLocation::getHashValue() const { 54 return llvm::DenseMapInfo<UIntTy>::getHashValue(ID); 55 } 56 57 void llvm::FoldingSetTrait<SourceLocation>::Profile( 58 const SourceLocation &X, llvm::FoldingSetNodeID &ID) { 59 ID.AddInteger(X.ID); 60 } 61 62 void SourceLocation::print(raw_ostream &OS, const SourceManager &SM)const{ 63 if (!isValid()) { 64 OS << "<invalid loc>"; 65 return; 66 } 67 68 if (isFileID()) { 69 PresumedLoc PLoc = SM.getPresumedLoc(*this); 70 71 if (PLoc.isInvalid()) { 72 OS << "<invalid>"; 73 return; 74 } 75 // The macro expansion and spelling pos is identical for file locs. 76 OS << PLoc.getFilename() << ':' << PLoc.getLine() 77 << ':' << PLoc.getColumn(); 78 return; 79 } 80 81 SM.getExpansionLoc(*this).print(OS, SM); 82 83 OS << " <Spelling="; 84 SM.getSpellingLoc(*this).print(OS, SM); 85 OS << '>'; 86 } 87 88 LLVM_DUMP_METHOD std::string 89 SourceLocation::printToString(const SourceManager &SM) const { 90 std::string S; 91 llvm::raw_string_ostream OS(S); 92 print(OS, SM); 93 return S; 94 } 95 96 LLVM_DUMP_METHOD void SourceLocation::dump(const SourceManager &SM) const { 97 print(llvm::errs(), SM); 98 llvm::errs() << '\n'; 99 } 100 101 LLVM_DUMP_METHOD void SourceRange::dump(const SourceManager &SM) const { 102 print(llvm::errs(), SM); 103 llvm::errs() << '\n'; 104 } 105 106 static PresumedLoc PrintDifference(raw_ostream &OS, const SourceManager &SM, 107 SourceLocation Loc, PresumedLoc Previous) { 108 if (Loc.isFileID()) { 109 110 PresumedLoc PLoc = SM.getPresumedLoc(Loc); 111 112 if (PLoc.isInvalid()) { 113 OS << "<invalid sloc>"; 114 return Previous; 115 } 116 117 if (Previous.isInvalid() || 118 strcmp(PLoc.getFilename(), Previous.getFilename()) != 0) { 119 OS << PLoc.getFilename() << ':' << PLoc.getLine() << ':' 120 << PLoc.getColumn(); 121 } else if (Previous.isInvalid() || PLoc.getLine() != Previous.getLine()) { 122 OS << "line" << ':' << PLoc.getLine() << ':' << PLoc.getColumn(); 123 } else { 124 OS << "col" << ':' << PLoc.getColumn(); 125 } 126 return PLoc; 127 } 128 auto PrintedLoc = PrintDifference(OS, SM, SM.getExpansionLoc(Loc), Previous); 129 130 OS << " <Spelling="; 131 PrintedLoc = PrintDifference(OS, SM, SM.getSpellingLoc(Loc), PrintedLoc); 132 OS << '>'; 133 return PrintedLoc; 134 } 135 136 void SourceRange::print(raw_ostream &OS, const SourceManager &SM) const { 137 138 OS << '<'; 139 auto PrintedLoc = PrintDifference(OS, SM, B, {}); 140 if (B != E) { 141 OS << ", "; 142 PrintDifference(OS, SM, E, PrintedLoc); 143 } 144 OS << '>'; 145 } 146 147 LLVM_DUMP_METHOD std::string 148 SourceRange::printToString(const SourceManager &SM) const { 149 std::string S; 150 llvm::raw_string_ostream OS(S); 151 print(OS, SM); 152 return S; 153 } 154 155 //===----------------------------------------------------------------------===// 156 // FullSourceLoc 157 //===----------------------------------------------------------------------===// 158 159 FileID FullSourceLoc::getFileID() const { 160 assert(isValid()); 161 return SrcMgr->getFileID(*this); 162 } 163 164 FullSourceLoc FullSourceLoc::getExpansionLoc() const { 165 assert(isValid()); 166 return FullSourceLoc(SrcMgr->getExpansionLoc(*this), *SrcMgr); 167 } 168 169 std::pair<FileID, unsigned> FullSourceLoc::getDecomposedExpansionLoc() const { 170 return SrcMgr->getDecomposedExpansionLoc(*this); 171 } 172 173 FullSourceLoc FullSourceLoc::getSpellingLoc() const { 174 assert(isValid()); 175 return FullSourceLoc(SrcMgr->getSpellingLoc(*this), *SrcMgr); 176 } 177 178 FullSourceLoc FullSourceLoc::getFileLoc() const { 179 assert(isValid()); 180 return FullSourceLoc(SrcMgr->getFileLoc(*this), *SrcMgr); 181 } 182 183 PresumedLoc FullSourceLoc::getPresumedLoc(bool UseLineDirectives) const { 184 if (!isValid()) 185 return PresumedLoc(); 186 187 return SrcMgr->getPresumedLoc(*this, UseLineDirectives); 188 } 189 190 bool FullSourceLoc::isMacroArgExpansion(FullSourceLoc *StartLoc) const { 191 assert(isValid()); 192 return SrcMgr->isMacroArgExpansion(*this, StartLoc); 193 } 194 195 FullSourceLoc FullSourceLoc::getImmediateMacroCallerLoc() const { 196 assert(isValid()); 197 return FullSourceLoc(SrcMgr->getImmediateMacroCallerLoc(*this), *SrcMgr); 198 } 199 200 std::pair<FullSourceLoc, StringRef> FullSourceLoc::getModuleImportLoc() const { 201 if (!isValid()) 202 return std::make_pair(FullSourceLoc(), StringRef()); 203 204 std::pair<SourceLocation, StringRef> ImportLoc = 205 SrcMgr->getModuleImportLoc(*this); 206 return std::make_pair(FullSourceLoc(ImportLoc.first, *SrcMgr), 207 ImportLoc.second); 208 } 209 210 unsigned FullSourceLoc::getFileOffset() const { 211 assert(isValid()); 212 return SrcMgr->getFileOffset(*this); 213 } 214 215 unsigned FullSourceLoc::getLineNumber(bool *Invalid) const { 216 assert(isValid()); 217 return SrcMgr->getLineNumber(getFileID(), getFileOffset(), Invalid); 218 } 219 220 unsigned FullSourceLoc::getColumnNumber(bool *Invalid) const { 221 assert(isValid()); 222 return SrcMgr->getColumnNumber(getFileID(), getFileOffset(), Invalid); 223 } 224 225 const FileEntry *FullSourceLoc::getFileEntry() const { 226 assert(isValid()); 227 return SrcMgr->getFileEntryForID(getFileID()); 228 } 229 230 OptionalFileEntryRef FullSourceLoc::getFileEntryRef() const { 231 assert(isValid()); 232 return SrcMgr->getFileEntryRefForID(getFileID()); 233 } 234 235 unsigned FullSourceLoc::getExpansionLineNumber(bool *Invalid) const { 236 assert(isValid()); 237 return SrcMgr->getExpansionLineNumber(*this, Invalid); 238 } 239 240 unsigned FullSourceLoc::getExpansionColumnNumber(bool *Invalid) const { 241 assert(isValid()); 242 return SrcMgr->getExpansionColumnNumber(*this, Invalid); 243 } 244 245 unsigned FullSourceLoc::getSpellingLineNumber(bool *Invalid) const { 246 assert(isValid()); 247 return SrcMgr->getSpellingLineNumber(*this, Invalid); 248 } 249 250 unsigned FullSourceLoc::getSpellingColumnNumber(bool *Invalid) const { 251 assert(isValid()); 252 return SrcMgr->getSpellingColumnNumber(*this, Invalid); 253 } 254 255 bool FullSourceLoc::isInSystemHeader() const { 256 assert(isValid()); 257 return SrcMgr->isInSystemHeader(*this); 258 } 259 260 bool FullSourceLoc::isBeforeInTranslationUnitThan(SourceLocation Loc) const { 261 assert(isValid()); 262 return SrcMgr->isBeforeInTranslationUnit(*this, Loc); 263 } 264 265 LLVM_DUMP_METHOD void FullSourceLoc::dump() const { 266 SourceLocation::dump(*SrcMgr); 267 } 268 269 const char *FullSourceLoc::getCharacterData(bool *Invalid) const { 270 assert(isValid()); 271 return SrcMgr->getCharacterData(*this, Invalid); 272 } 273 274 StringRef FullSourceLoc::getBufferData(bool *Invalid) const { 275 assert(isValid()); 276 return SrcMgr->getBufferData(SrcMgr->getFileID(*this), Invalid); 277 } 278 279 std::pair<FileID, unsigned> FullSourceLoc::getDecomposedLoc() const { 280 return SrcMgr->getDecomposedLoc(*this); 281 } 282