contrib/llvm-project/clang/lib/Basic/SourceLocation.cpp

   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/StringRef.h"
  18 #include "llvm/Support/Compiler.h"
  19 #include "llvm/Support/MemoryBuffer.h"
  20 #include "llvm/Support/raw_ostream.h"
  21 #include <cassert>
  22 #include <string>
  23 #include <utility>
  24
  25 using namespace clang;
  26
  27 //===----------------------------------------------------------------------===//
  28 // PrettyStackTraceLoc
  29 //===----------------------------------------------------------------------===//
  30
  31 void PrettyStackTraceLoc::print(raw_ostream &OS) const {
  32   if (Loc.isValid()) {
  33     Loc.print(OS, SM);
  34     OS << ": ";
  35   }
  36   OS << Message << '\n';
  37 }
  38
  39 //===----------------------------------------------------------------------===//
  40 // SourceLocation
  41 //===----------------------------------------------------------------------===//
  42
  43 void SourceLocation::print(raw_ostream &OS, const SourceManager &SM)const{
  44   if (!isValid()) {
  45     OS << "<invalid loc>";
  46     return;
  47   }
  48
  49   if (isFileID()) {
  50     PresumedLoc PLoc = SM.getPresumedLoc(*this);
  51
  52     if (PLoc.isInvalid()) {
  53       OS << "<invalid>";
  54       return;
  55     }
  56     // The macro expansion and spelling pos is identical for file locs.
  57     OS << PLoc.getFilename() << ':' << PLoc.getLine()
  58        << ':' << PLoc.getColumn();
  59     return;
  60   }
  61
  62   SM.getExpansionLoc(*this).print(OS, SM);
  63
  64   OS << " <Spelling=";
  65   SM.getSpellingLoc(*this).print(OS, SM);
  66   OS << '>';
  67 }
  68
  69 LLVM_DUMP_METHOD std::string
  70 SourceLocation::printToString(const SourceManager &SM) const {
  71   std::string S;
  72   llvm::raw_string_ostream OS(S);
  73   print(OS, SM);
  74   return OS.str();
  75 }
  76
  77 LLVM_DUMP_METHOD void SourceLocation::dump(const SourceManager &SM) const {
  78   print(llvm::errs(), SM);
  79   llvm::errs() << '\n';
  80 }
  81
  82 LLVM_DUMP_METHOD void SourceRange::dump(const SourceManager &SM) const {
  83   print(llvm::errs(), SM);
  84   llvm::errs() << '\n';
  85 }
  86
  87 static PresumedLoc PrintDifference(raw_ostream &OS, const SourceManager &SM,
  88                                    SourceLocation Loc, PresumedLoc Previous) {
  89   if (Loc.isFileID()) {
  90
  91     PresumedLoc PLoc = SM.getPresumedLoc(Loc);
  92
  93     if (PLoc.isInvalid()) {
  94       OS << "<invalid sloc>";
  95       return Previous;
  96     }
  97
  98     if (Previous.isInvalid() ||
  99         strcmp(PLoc.getFilename(), Previous.getFilename()) != 0) {
 100       OS << PLoc.getFilename() << ':' << PLoc.getLine() << ':'
 101          << PLoc.getColumn();
 102     } else if (Previous.isInvalid() || PLoc.getLine() != Previous.getLine()) {
 103       OS << "line" << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
 104     } else {
 105       OS << "col" << ':' << PLoc.getColumn();
 106     }
 107     return PLoc;
 108   }
 109   auto PrintedLoc = PrintDifference(OS, SM, SM.getExpansionLoc(Loc), Previous);
 110
 111   OS << " <Spelling=";
 112   PrintedLoc = PrintDifference(OS, SM, SM.getSpellingLoc(Loc), PrintedLoc);
 113   OS << '>';
 114   return PrintedLoc;
 115 }
 116
 117 void SourceRange::print(raw_ostream &OS, const SourceManager &SM) const {
 118
 119   OS << '<';
 120   auto PrintedLoc = PrintDifference(OS, SM, B, {});
 121   if (B != E) {
 122     OS << ", ";
 123     PrintDifference(OS, SM, E, PrintedLoc);
 124   }
 125   OS << '>';
 126 }
 127
 128 LLVM_DUMP_METHOD std::string
 129 SourceRange::printToString(const SourceManager &SM) const {
 130   std::string S;
 131   llvm::raw_string_ostream OS(S);
 132   print(OS, SM);
 133   return OS.str();
 134 }
 135
 136 //===----------------------------------------------------------------------===//
 137 // FullSourceLoc
 138 //===----------------------------------------------------------------------===//
 139
 140 FileID FullSourceLoc::getFileID() const {
 141   assert(isValid());
 142   return SrcMgr->getFileID(*this);
 143 }
 144
 145 FullSourceLoc FullSourceLoc::getExpansionLoc() const {
 146   assert(isValid());
 147   return FullSourceLoc(SrcMgr->getExpansionLoc(*this), *SrcMgr);
 148 }
 149
 150 FullSourceLoc FullSourceLoc::getSpellingLoc() const {
 151   assert(isValid());
 152   return FullSourceLoc(SrcMgr->getSpellingLoc(*this), *SrcMgr);
 153 }
 154
 155 FullSourceLoc FullSourceLoc::getFileLoc() const {
 156   assert(isValid());
 157   return FullSourceLoc(SrcMgr->getFileLoc(*this), *SrcMgr);
 158 }
 159
 160 PresumedLoc FullSourceLoc::getPresumedLoc(bool UseLineDirectives) const {
 161   if (!isValid())
 162     return PresumedLoc();
 163
 164   return SrcMgr->getPresumedLoc(*this, UseLineDirectives);
 165 }
 166
 167 bool FullSourceLoc::isMacroArgExpansion(FullSourceLoc *StartLoc) const {
 168   assert(isValid());
 169   return SrcMgr->isMacroArgExpansion(*this, StartLoc);
 170 }
 171
 172 FullSourceLoc FullSourceLoc::getImmediateMacroCallerLoc() const {
 173   assert(isValid());
 174   return FullSourceLoc(SrcMgr->getImmediateMacroCallerLoc(*this), *SrcMgr);
 175 }
 176
 177 std::pair<FullSourceLoc, StringRef> FullSourceLoc::getModuleImportLoc() const {
 178   if (!isValid())
 179     return std::make_pair(FullSourceLoc(), StringRef());
 180
 181   std::pair<SourceLocation, StringRef> ImportLoc =
 182       SrcMgr->getModuleImportLoc(*this);
 183   return std::make_pair(FullSourceLoc(ImportLoc.first, *SrcMgr),
 184                         ImportLoc.second);
 185 }
 186
 187 unsigned FullSourceLoc::getFileOffset() const {
 188   assert(isValid());
 189   return SrcMgr->getFileOffset(*this);
 190 }
 191
 192 unsigned FullSourceLoc::getLineNumber(bool *Invalid) const {
 193   assert(isValid());
 194   return SrcMgr->getLineNumber(getFileID(), getFileOffset(), Invalid);
 195 }
 196
 197 unsigned FullSourceLoc::getColumnNumber(bool *Invalid) const {
 198   assert(isValid());
 199   return SrcMgr->getColumnNumber(getFileID(), getFileOffset(), Invalid);
 200 }
 201
 202 const FileEntry *FullSourceLoc::getFileEntry() const {
 203   assert(isValid());
 204   return SrcMgr->getFileEntryForID(getFileID());
 205 }
 206
 207 unsigned FullSourceLoc::getExpansionLineNumber(bool *Invalid) const {
 208   assert(isValid());
 209   return SrcMgr->getExpansionLineNumber(*this, Invalid);
 210 }
 211
 212 unsigned FullSourceLoc::getExpansionColumnNumber(bool *Invalid) const {
 213   assert(isValid());
 214   return SrcMgr->getExpansionColumnNumber(*this, Invalid);
 215 }
 216
 217 unsigned FullSourceLoc::getSpellingLineNumber(bool *Invalid) const {
 218   assert(isValid());
 219   return SrcMgr->getSpellingLineNumber(*this, Invalid);
 220 }
 221
 222 unsigned FullSourceLoc::getSpellingColumnNumber(bool *Invalid) const {
 223   assert(isValid());
 224   return SrcMgr->getSpellingColumnNumber(*this, Invalid);
 225 }
 226
 227 bool FullSourceLoc::isInSystemHeader() const {
 228   assert(isValid());
 229   return SrcMgr->isInSystemHeader(*this);
 230 }
 231
 232 bool FullSourceLoc::isBeforeInTranslationUnitThan(SourceLocation Loc) const {
 233   assert(isValid());
 234   return SrcMgr->isBeforeInTranslationUnit(*this, Loc);
 235 }
 236
 237 LLVM_DUMP_METHOD void FullSourceLoc::dump() const {
 238   SourceLocation::dump(*SrcMgr);
 239 }
 240
 241 const char *FullSourceLoc::getCharacterData(bool *Invalid) const {
 242   assert(isValid());
 243   return SrcMgr->getCharacterData(*this, Invalid);
 244 }
 245
 246 StringRef FullSourceLoc::getBufferData(bool *Invalid) const {
 247   assert(isValid());
 248   return SrcMgr->getBuffer(SrcMgr->getFileID(*this), Invalid)->getBuffer();
 249 }
 250
 251 std::pair<FileID, unsigned> FullSourceLoc::getDecomposedLoc() const {
 252   return SrcMgr->getDecomposedLoc(*this);
 253 }