1 //===- SourceMgr.h - Manager for Source Buffers & Diagnostics ---*- C++ -*-===// 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 declares the SMDiagnostic and SourceMgr classes. This 11 // provides a simple substrate for diagnostics, #include handling, and other low 12 // level things for simple parsers. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_SUPPORT_SOURCEMGR_H 17 #define LLVM_SUPPORT_SOURCEMGR_H 18 19 #include "llvm/ADT/ArrayRef.h" 20 #include "llvm/ADT/StringRef.h" 21 #include "llvm/ADT/Twine.h" 22 #include "llvm/Support/MemoryBuffer.h" 23 #include "llvm/Support/SMLoc.h" 24 #include <string> 25 26 namespace llvm { 27 class SourceMgr; 28 class SMDiagnostic; 29 class SMFixIt; 30 class Twine; 31 class raw_ostream; 32 33 /// This owns the files read by a parser, handles include stacks, 34 /// and handles diagnostic wrangling. 35 class SourceMgr { 36 public: 37 enum DiagKind { 38 DK_Error, 39 DK_Warning, 40 DK_Note 41 }; 42 43 /// Clients that want to handle their own diagnostics in a custom way can 44 /// register a function pointer+context as a diagnostic handler. 45 /// It gets called each time PrintMessage is invoked. 46 typedef void (*DiagHandlerTy)(const SMDiagnostic &, void *Context); 47 private: 48 struct SrcBuffer { 49 /// The memory buffer for the file. 50 std::unique_ptr<MemoryBuffer> Buffer; 51 52 /// This is the location of the parent include, or null if at the top level. 53 SMLoc IncludeLoc; 54 }; 55 56 /// This is all of the buffers that we are reading from. 57 std::vector<SrcBuffer> Buffers; 58 59 // This is the list of directories we should search for include files in. 60 std::vector<std::string> IncludeDirectories; 61 62 /// This is a cache for line number queries, its implementation is really 63 /// private to SourceMgr.cpp. 64 mutable void *LineNoCache; 65 66 DiagHandlerTy DiagHandler; 67 void *DiagContext; 68 69 bool isValidBufferID(unsigned i) const { return i && i <= Buffers.size(); } 70 71 SourceMgr(const SourceMgr&) = delete; 72 void operator=(const SourceMgr&) = delete; 73 public: 74 SourceMgr() 75 : LineNoCache(nullptr), DiagHandler(nullptr), DiagContext(nullptr) {} 76 ~SourceMgr(); 77 78 void setIncludeDirs(const std::vector<std::string> &Dirs) { 79 IncludeDirectories = Dirs; 80 } 81 82 /// Specify a diagnostic handler to be invoked every time PrintMessage is 83 /// called. \p Ctx is passed into the handler when it is invoked. 84 void setDiagHandler(DiagHandlerTy DH, void *Ctx = nullptr) { 85 DiagHandler = DH; 86 DiagContext = Ctx; 87 } 88 89 DiagHandlerTy getDiagHandler() const { return DiagHandler; } 90 void *getDiagContext() const { return DiagContext; } 91 92 const SrcBuffer &getBufferInfo(unsigned i) const { 93 assert(isValidBufferID(i)); 94 return Buffers[i - 1]; 95 } 96 97 const MemoryBuffer *getMemoryBuffer(unsigned i) const { 98 assert(isValidBufferID(i)); 99 return Buffers[i - 1].Buffer.get(); 100 } 101 102 unsigned getNumBuffers() const { 103 return Buffers.size(); 104 } 105 106 unsigned getMainFileID() const { 107 assert(getNumBuffers()); 108 return 1; 109 } 110 111 SMLoc getParentIncludeLoc(unsigned i) const { 112 assert(isValidBufferID(i)); 113 return Buffers[i - 1].IncludeLoc; 114 } 115 116 /// Add a new source buffer to this source manager. This takes ownership of 117 /// the memory buffer. 118 unsigned AddNewSourceBuffer(std::unique_ptr<MemoryBuffer> F, 119 SMLoc IncludeLoc) { 120 SrcBuffer NB; 121 NB.Buffer = std::move(F); 122 NB.IncludeLoc = IncludeLoc; 123 Buffers.push_back(std::move(NB)); 124 return Buffers.size(); 125 } 126 127 /// Search for a file with the specified name in the current directory or in 128 /// one of the IncludeDirs. 129 /// 130 /// If no file is found, this returns 0, otherwise it returns the buffer ID 131 /// of the stacked file. The full path to the included file can be found in 132 /// \p IncludedFile. 133 unsigned AddIncludeFile(const std::string &Filename, SMLoc IncludeLoc, 134 std::string &IncludedFile); 135 136 /// Return the ID of the buffer containing the specified location. 137 /// 138 /// 0 is returned if the buffer is not found. 139 unsigned FindBufferContainingLoc(SMLoc Loc) const; 140 141 /// Find the line number for the specified location in the specified file. 142 /// This is not a fast method. 143 unsigned FindLineNumber(SMLoc Loc, unsigned BufferID = 0) const { 144 return getLineAndColumn(Loc, BufferID).first; 145 } 146 147 /// Find the line and column number for the specified location in the 148 /// specified file. This is not a fast method. 149 std::pair<unsigned, unsigned> getLineAndColumn(SMLoc Loc, 150 unsigned BufferID = 0) const; 151 152 /// Emit a message about the specified location with the specified string. 153 /// 154 /// \param ShowColors Display colored messages if output is a terminal and 155 /// the default error handler is used. 156 void PrintMessage(raw_ostream &OS, SMLoc Loc, DiagKind Kind, 157 const Twine &Msg, 158 ArrayRef<SMRange> Ranges = None, 159 ArrayRef<SMFixIt> FixIts = None, 160 bool ShowColors = true) const; 161 162 /// Emits a diagnostic to llvm::errs(). 163 void PrintMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg, 164 ArrayRef<SMRange> Ranges = None, 165 ArrayRef<SMFixIt> FixIts = None, 166 bool ShowColors = true) const; 167 168 /// Emits a manually-constructed diagnostic to the given output stream. 169 /// 170 /// \param ShowColors Display colored messages if output is a terminal and 171 /// the default error handler is used. 172 void PrintMessage(raw_ostream &OS, const SMDiagnostic &Diagnostic, 173 bool ShowColors = true) const; 174 175 /// Return an SMDiagnostic at the specified location with the specified 176 /// string. 177 /// 178 /// \param Msg If non-null, the kind of message (e.g., "error") which is 179 /// prefixed to the message. 180 SMDiagnostic GetMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg, 181 ArrayRef<SMRange> Ranges = None, 182 ArrayRef<SMFixIt> FixIts = None) const; 183 184 /// Prints the names of included files and the line of the file they were 185 /// included from. A diagnostic handler can use this before printing its 186 /// custom formatted message. 187 /// 188 /// \param IncludeLoc The location of the include. 189 /// \param OS the raw_ostream to print on. 190 void PrintIncludeStack(SMLoc IncludeLoc, raw_ostream &OS) const; 191 }; 192 193 194 /// Represents a single fixit, a replacement of one range of text with another. 195 class SMFixIt { 196 SMRange Range; 197 198 std::string Text; 199 200 public: 201 // FIXME: Twine.str() is not very efficient. 202 SMFixIt(SMLoc Loc, const Twine &Insertion) 203 : Range(Loc, Loc), Text(Insertion.str()) { 204 assert(Loc.isValid()); 205 } 206 207 // FIXME: Twine.str() is not very efficient. 208 SMFixIt(SMRange R, const Twine &Replacement) 209 : Range(R), Text(Replacement.str()) { 210 assert(R.isValid()); 211 } 212 213 StringRef getText() const { return Text; } 214 SMRange getRange() const { return Range; } 215 216 bool operator<(const SMFixIt &Other) const { 217 if (Range.Start.getPointer() != Other.Range.Start.getPointer()) 218 return Range.Start.getPointer() < Other.Range.Start.getPointer(); 219 if (Range.End.getPointer() != Other.Range.End.getPointer()) 220 return Range.End.getPointer() < Other.Range.End.getPointer(); 221 return Text < Other.Text; 222 } 223 }; 224 225 226 /// Instances of this class encapsulate one diagnostic report, allowing 227 /// printing to a raw_ostream as a caret diagnostic. 228 class SMDiagnostic { 229 const SourceMgr *SM; 230 SMLoc Loc; 231 std::string Filename; 232 int LineNo, ColumnNo; 233 SourceMgr::DiagKind Kind; 234 std::string Message, LineContents; 235 std::vector<std::pair<unsigned, unsigned> > Ranges; 236 SmallVector<SMFixIt, 4> FixIts; 237 238 public: 239 // Null diagnostic. 240 SMDiagnostic() 241 : SM(nullptr), LineNo(0), ColumnNo(0), Kind(SourceMgr::DK_Error) {} 242 // Diagnostic with no location (e.g. file not found, command line arg error). 243 SMDiagnostic(StringRef filename, SourceMgr::DiagKind Knd, StringRef Msg) 244 : SM(nullptr), Filename(filename), LineNo(-1), ColumnNo(-1), Kind(Knd), 245 Message(Msg) {} 246 247 // Diagnostic with a location. 248 SMDiagnostic(const SourceMgr &sm, SMLoc L, StringRef FN, 249 int Line, int Col, SourceMgr::DiagKind Kind, 250 StringRef Msg, StringRef LineStr, 251 ArrayRef<std::pair<unsigned,unsigned> > Ranges, 252 ArrayRef<SMFixIt> FixIts = None); 253 254 const SourceMgr *getSourceMgr() const { return SM; } 255 SMLoc getLoc() const { return Loc; } 256 StringRef getFilename() const { return Filename; } 257 int getLineNo() const { return LineNo; } 258 int getColumnNo() const { return ColumnNo; } 259 SourceMgr::DiagKind getKind() const { return Kind; } 260 StringRef getMessage() const { return Message; } 261 StringRef getLineContents() const { return LineContents; } 262 ArrayRef<std::pair<unsigned, unsigned> > getRanges() const { 263 return Ranges; 264 } 265 266 void addFixIt(const SMFixIt &Hint) { 267 FixIts.push_back(Hint); 268 } 269 270 ArrayRef<SMFixIt> getFixIts() const { 271 return FixIts; 272 } 273 274 void print(const char *ProgName, raw_ostream &S, bool ShowColors = true, 275 bool ShowKindLabel = true) const; 276 }; 277 278 } // end llvm namespace 279 280 #endif 281
