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