lib/Support/SourceMgr.cpp

   1 //===- SourceMgr.cpp - Manager for Simple Source Buffers & Diagnostics ----===//
   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 SourceMgr class.  This class is used as a simple
  11 // substrate for diagnostics, #include handling, and other low level things for
  12 // simple parsers.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "llvm/Support/SourceMgr.h"
  17 #include "llvm/Support/MemoryBuffer.h"
  18 #include "llvm/Support/raw_ostream.h"
  19 using namespace llvm;
  20
  21 SourceMgr::~SourceMgr() {
  22   while (!Buffers.empty()) {
  23     delete Buffers.back().Buffer;
  24     Buffers.pop_back();
  25   }
  26 }
  27
  28 /// AddIncludeFile - Search for a file with the specified name in the current
  29 /// directory or in one of the IncludeDirs.  If no file is found, this returns
  30 /// ~0, otherwise it returns the buffer ID of the stacked file.
  31 unsigned SourceMgr::AddIncludeFile(const std::string &Filename,
  32                                    SMLoc IncludeLoc) {
  33
  34   MemoryBuffer *NewBuf = MemoryBuffer::getFile(Filename.c_str());
  35
  36   // If the file didn't exist directly, see if it's in an include path.
  37   for (unsigned i = 0, e = IncludeDirectories.size(); i != e && !NewBuf; ++i) {
  38     std::string IncFile = IncludeDirectories[i] + "/" + Filename;
  39     NewBuf = MemoryBuffer::getFile(IncFile.c_str());
  40   }
  41
  42   if (NewBuf == 0) return ~0U;
  43
  44   return AddNewSourceBuffer(NewBuf, IncludeLoc);
  45 }
  46
  47
  48 /// FindBufferContainingLoc - Return the ID of the buffer containing the
  49 /// specified location, returning -1 if not found.
  50 int SourceMgr::FindBufferContainingLoc(SMLoc Loc) const {
  51   for (unsigned i = 0, e = Buffers.size(); i != e; ++i)
  52     if (Loc.getPointer() >= Buffers[i].Buffer->getBufferStart() &&
  53         // Use <= here so that a pointer to the null at the end of the buffer
  54         // is included as part of the buffer.
  55         Loc.getPointer() <= Buffers[i].Buffer->getBufferEnd())
  56       return i;
  57   return -1;
  58 }
  59
  60 /// FindLineNumber - Find the line number for the specified location in the
  61 /// specified file.  This is not a fast method.
  62 unsigned SourceMgr::FindLineNumber(SMLoc Loc, int BufferID) const {
  63   if (BufferID == -1) BufferID = FindBufferContainingLoc(Loc);
  64   assert(BufferID != -1 && "Invalid Location!");
  65
  66   MemoryBuffer *Buff = getBufferInfo(BufferID).Buffer;
  67
  68   // Count the number of \n's between the start of the file and the specified
  69   // location.
  70   unsigned LineNo = 1;
  71
  72   const char *Ptr = Buff->getBufferStart();
  73
  74   for (; SMLoc::getFromPointer(Ptr) != Loc; ++Ptr)
  75     if (*Ptr == '\n') ++LineNo;
  76   return LineNo;
  77 }
  78
  79 void SourceMgr::PrintIncludeStack(SMLoc IncludeLoc, raw_ostream &OS) const {
  80   if (IncludeLoc == SMLoc()) return;  // Top of stack.
  81
  82   int CurBuf = FindBufferContainingLoc(IncludeLoc);
  83   assert(CurBuf != -1 && "Invalid or unspecified location!");
  84
  85   PrintIncludeStack(getBufferInfo(CurBuf).IncludeLoc, OS);
  86
  87   OS << "Included from "
  88      << getBufferInfo(CurBuf).Buffer->getBufferIdentifier()
  89      << ":" << FindLineNumber(IncludeLoc, CurBuf) << ":\n";
  90 }
  91
  92
  93 void SourceMgr::PrintMessage(SMLoc Loc, const std::string &Msg,
  94                              const char *Type) const {
  95   raw_ostream &OS = errs();
  96
  97   // First thing to do: find the current buffer containing the specified
  98   // location.
  99   int CurBuf = FindBufferContainingLoc(Loc);
 100   assert(CurBuf != -1 && "Invalid or unspecified location!");
 101
 102   PrintIncludeStack(getBufferInfo(CurBuf).IncludeLoc, OS);
 103
 104   MemoryBuffer *CurMB = getBufferInfo(CurBuf).Buffer;
 105
 106
 107   // Scan backward to find the start of the line.
 108   const char *LineStart = Loc.getPointer();
 109   while (LineStart != CurMB->getBufferStart() &&
 110          LineStart[-1] != '\n' && LineStart[-1] != '\r')
 111     --LineStart;
 112   // Get the end of the line.
 113   const char *LineEnd = Loc.getPointer();
 114   while (LineEnd != CurMB->getBufferEnd() &&
 115          LineEnd[0] != '\n' && LineEnd[0] != '\r')
 116     ++LineEnd;
 117
 118   std::string PrintedMsg;
 119   if (Type) {
 120     PrintedMsg = Type;
 121     PrintedMsg += ": ";
 122   }
 123   PrintedMsg += Msg;
 124
 125
 126   // Print out the line.
 127   SMDiagnostic(CurMB->getBufferIdentifier(), FindLineNumber(Loc, CurBuf),
 128                Loc.getPointer()-LineStart, PrintedMsg,
 129                std::string(LineStart, LineEnd)).Print(0, OS);
 130
 131 }
 132
 133 //===----------------------------------------------------------------------===//
 134 // SMDiagnostic Implementation
 135 //===----------------------------------------------------------------------===//
 136
 137 void SMDiagnostic::Print(const char *ProgName, raw_ostream &S) {
 138   if (ProgName && ProgName[0])
 139     S << ProgName << ": ";
 140
 141   if (Filename == "-")
 142     S << "<stdin>";
 143   else
 144     S << Filename;
 145
 146   if (LineNo != -1) {
 147     S << ':' << LineNo;
 148     if (ColumnNo != -1)
 149       S << ':' << (ColumnNo+1);
 150   }
 151
 152   S << ": " << Message << '\n';
 153
 154   if (LineNo != -1 && ColumnNo != -1) {
 155     S << LineContents << '\n';
 156
 157     // Print out spaces/tabs before the caret.
 158     for (unsigned i = 0; i != unsigned(ColumnNo); ++i)
 159       S << (LineContents[i] == '\t' ? '\t' : ' ');
 160     S << "^\n";
 161   }
 162 }
 163
 164