switch the .ll parser to use SourceMgr.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@74735 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Support/SourceMgr.h b/include/llvm/Support/SourceMgr.h
index 0260d2d751821dfd71657fe4338cc7c5aed492c0..7c8a139091bfb565bd4cecc911d0f4cf42d57715 100644 (file)
--- a/include/llvm/Support/SourceMgr.h
+++ b/include/llvm/Support/SourceMgr.h
@@ -118,6 +118,16 @@ public:
   /// prefixed to the message.
   void PrintMessage(SMLoc Loc, const std::string &Msg, const char *Type) const;
   
+  
+  /// GetMessage - Return an SMDiagnostic at the specified location with the
+  /// specified string.
+  ///
+  /// @param Type - If non-null, the kind of message (e.g., "error") which is
+  /// prefixed to the message.
+  SMDiagnostic GetMessage(SMLoc Loc,
+                          const std::string &Msg, const char *Type) const;
+  
+  
 private:
   void PrintIncludeStack(SMLoc IncludeLoc, raw_ostream &OS) const;
 };

diff --git a/lib/AsmParser/LLLexer.cpp b/lib/AsmParser/LLLexer.cpp
index 090e6141227bff6c3c4a3309ef4cb8b582e25d49..741c5381fc78a3511fdb130de2fb96e38f5daca5 100644 (file)
--- a/lib/AsmParser/LLLexer.cpp
+++ b/lib/AsmParser/LLLexer.cpp
@@ -24,24 +24,7 @@
 using namespace llvm;
 
 bool LLLexer::Error(LocTy ErrorLoc, const std::string &Msg) const {
-  // Scan backward to find the start of the line.
-  const char *LineStart = ErrorLoc;
-  while (LineStart != CurBuf->getBufferStart() &&
-         LineStart[-1] != '\n' && LineStart[-1] != '\r')
-    --LineStart;
-  // Get the end of the line.
-  const char *LineEnd = ErrorLoc;
-  while (LineEnd != CurBuf->getBufferEnd() &&
-         LineEnd[0] != '\n' && LineEnd[0] != '\r')
-    ++LineEnd;
-
-  unsigned LineNo = 1;
-  for (const char *FP = CurBuf->getBufferStart(); FP != ErrorLoc; ++FP)
-    if (*FP == '\n') ++LineNo;
-
-  ErrorInfo = SMDiagnostic(CurBuf->getBufferIdentifier(),
-                           LineNo, ErrorLoc-LineStart, Msg,
-                           std::string(LineStart, LineEnd));
+  ErrorInfo = SM.GetMessage(ErrorLoc, Msg, "error");
   return true;
 }
 
@@ -197,8 +180,8 @@ static const char *isLabelTail(const char *CurPtr) {
 // Lexer definition.
 //===----------------------------------------------------------------------===//
 
-LLLexer::LLLexer(MemoryBuffer *StartBuf, SMDiagnostic &Err)
-  : CurBuf(StartBuf), ErrorInfo(Err), APFloatVal(0.0) {
+LLLexer::LLLexer(MemoryBuffer *StartBuf, SourceMgr &sm, SMDiagnostic &Err)
+  : CurBuf(StartBuf), ErrorInfo(Err), SM(sm), APFloatVal(0.0) {
   CurPtr = CurBuf->getBufferStart();
 }
 

diff --git a/lib/AsmParser/LLLexer.h b/lib/AsmParser/LLLexer.h
index 49a63a16927a0fb0e7c478bb63bf251a99f9a5f4..b5e58f1418ec23a543b090bbb0b3772b64b4b257 100644 (file)
--- a/lib/AsmParser/LLLexer.h
+++ b/lib/AsmParser/LLLexer.h
@@ -17,6 +17,7 @@
 #include "LLToken.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/APFloat.h"
+#include "llvm/Support/SourceMgr.h"
 #include <string>
 
 namespace llvm {
@@ -28,6 +29,7 @@ namespace llvm {
     const char *CurPtr;
     MemoryBuffer *CurBuf;
     SMDiagnostic &ErrorInfo;
+    SourceMgr &SM;
 
     // Information about the current token.
     const char *TokStart;
@@ -40,15 +42,15 @@ namespace llvm {
 
     std::string TheError;
   public:
-    explicit LLLexer(MemoryBuffer *StartBuf, SMDiagnostic &);
+    explicit LLLexer(MemoryBuffer *StartBuf, SourceMgr &SM, SMDiagnostic &);
     ~LLLexer() {}
 
     lltok::Kind Lex() {
       return CurKind = LexToken();
     }
 
-    typedef const char* LocTy;
-    LocTy getLoc() const { return TokStart; }
+    typedef SMLoc LocTy;
+    LocTy getLoc() const { return SMLoc::getFromPointer(TokStart); }
     lltok::Kind getKind() const { return CurKind; }
     const std::string getStrVal() const { return StrVal; }
     const Type *getTyVal() const { return TyVal; }
@@ -58,7 +60,7 @@ namespace llvm {
 
 
     bool Error(LocTy L, const std::string &Msg) const;
-    bool Error(const std::string &Msg) const { return Error(CurPtr, Msg); }
+    bool Error(const std::string &Msg) const { return Error(getLoc(), Msg); }
     std::string getFilename() const;
 
   private:

diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp
index d5dbb52c0fff992234a20738b85182243402ef29..3966ab3b5fc6e0dbeb791dfd3b1888c3e24043de 100644 (file)
--- a/lib/AsmParser/LLParser.cpp
+++ b/lib/AsmParser/LLParser.cpp
@@ -131,7 +131,7 @@ bool LLParser::ParseTopLevelEntities() {
       unsigned Linkage, Visibility;
       if (ParseOptionalLinkage(Linkage) ||
           ParseOptionalVisibility(Visibility) ||
-          ParseGlobal("", 0, Linkage, true, Visibility))
+          ParseGlobal("", SMLoc(), Linkage, true, Visibility))
         return true;
       break;
     }
@@ -140,7 +140,7 @@ bool LLParser::ParseTopLevelEntities() {
     case lltok::kw_protected: {   // OptionalVisibility
       unsigned Visibility;
       if (ParseOptionalVisibility(Visibility) ||
-          ParseGlobal("", 0, 0, false, Visibility))
+          ParseGlobal("", SMLoc(), 0, false, Visibility))
         return true;
       break;
     }
@@ -149,7 +149,7 @@ bool LLParser::ParseTopLevelEntities() {
     case lltok::kw_addrspace:     // OptionalAddrSpace
     case lltok::kw_constant:      // GlobalType
     case lltok::kw_global:        // GlobalType
-      if (ParseGlobal("", 0, 0, false, 0)) return true;
+      if (ParseGlobal("", SMLoc(), 0, false, 0)) return true;
       break;
     }
   }
@@ -3162,7 +3162,7 @@ bool LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS,
                           unsigned Opc) {
   PATypeHolder Ty(Type::VoidTy);
   Value *Size = 0;
-  LocTy SizeLoc = 0;
+  LocTy SizeLoc;
   unsigned Alignment = 0;
   if (ParseType(Ty)) return true;
 

diff --git a/lib/AsmParser/LLParser.h b/lib/AsmParser/LLParser.h
index fdb21478103c7cf701676115268ead68247bbf80..6659620e6c9393a99d9b3e01c9f727f30d9256fa 100644 (file)
--- a/lib/AsmParser/LLParser.h
+++ b/lib/AsmParser/LLParser.h
@@ -73,8 +73,8 @@ namespace llvm {
     std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs;
     std::vector<GlobalValue*> NumberedVals;
   public:
-    LLParser(MemoryBuffer *F, SMDiagnostic &Err, Module *m) : 
-      Context(m->getContext()), Lex(F, Err), M(m) {}
+    LLParser(MemoryBuffer *F, SourceMgr &SM, SMDiagnostic &Err, Module *m) : 
+      Context(m->getContext()), Lex(F, SM, Err), M(m) {}
     bool Run();
 
     LLVMContext& getContext() { return Context; }

diff --git a/lib/AsmParser/Parser.cpp b/lib/AsmParser/Parser.cpp
index 17aae397eaa50d6112714423dca4b0904dddbd7c..d66c13d39c09f656efc511510ccdb6d2d43dce73 100644 (file)
--- a/lib/AsmParser/Parser.cpp
+++ b/lib/AsmParser/Parser.cpp
@@ -24,33 +24,38 @@ using namespace llvm;
 Module *llvm::ParseAssemblyFile(const std::string &Filename, SMDiagnostic &Err,
                                 LLVMContext &Context) {
   std::string ErrorStr;
-  OwningPtr<MemoryBuffer>
-    F(MemoryBuffer::getFileOrSTDIN(Filename.c_str(), &ErrorStr));
+  MemoryBuffer *F = MemoryBuffer::getFileOrSTDIN(Filename.c_str(), &ErrorStr);
   if (F == 0) {
     Err = SMDiagnostic("", -1, -1,
                        "Could not open input file '" + Filename + "'", "");
     return 0;
   }
 
+  SourceMgr SM;
+  SM.AddNewSourceBuffer(F, SMLoc());
+  
   OwningPtr<Module> M(new Module(Filename, Context));
-  if (LLParser(F.get(), Err, M.get()).Run())
+  if (LLParser(F, SM, Err, M.get()).Run())
     return 0;
   return M.take();
 }
 
 Module *llvm::ParseAssemblyString(const char *AsmString, Module *M,
                                   SMDiagnostic &Err, LLVMContext &Context) {
-  OwningPtr<MemoryBuffer>
-    F(MemoryBuffer::getMemBuffer(AsmString, AsmString+strlen(AsmString),
-                                 "<string>"));
+  MemoryBuffer *F =
+    MemoryBuffer::getMemBuffer(AsmString, AsmString+strlen(AsmString),
+                               "<string>");
   
+  SourceMgr SM;
+  SM.AddNewSourceBuffer(F, SMLoc());
+
   // If we are parsing into an existing module, do it.
   if (M)
-    return LLParser(F.get(), Err, M).Run() ? 0 : M;
+    return LLParser(F, SM, Err, M).Run() ? 0 : M;
 
   // Otherwise create a new module.
   OwningPtr<Module> M2(new Module("<string>", Context));
-  if (LLParser(F.get(), Err, M2.get()).Run())
+  if (LLParser(F, SM, Err, M2.get()).Run())
     return 0;
   return M2.take();
 }

diff --git a/lib/Support/SourceMgr.cpp b/lib/Support/SourceMgr.cpp
index 123531e21db53aa7047344cec3f49a9fb878c55c..6b0d55c19f22ab0fea2e8f3d276fbc654a1422fe 100644 (file)
--- a/lib/Support/SourceMgr.cpp
+++ b/lib/Support/SourceMgr.cpp
@@ -90,17 +90,19 @@ void SourceMgr::PrintIncludeStack(SMLoc IncludeLoc, raw_ostream &OS) const {
 }
 
 
-void SourceMgr::PrintMessage(SMLoc Loc, const std::string &Msg, 
-                             const char *Type) const {
-  raw_ostream &OS = errs();
+/// GetMessage - Return an SMDiagnostic at the specified location with the
+/// specified string.
+///
+/// @param Type - If non-null, the kind of message (e.g., "error") which is
+/// prefixed to the message.
+SMDiagnostic SourceMgr::GetMessage(SMLoc Loc, const std::string &Msg,
+                                   const char *Type) const {
   
   // First thing to do: find the current buffer containing the specified
   // location.
   int CurBuf = FindBufferContainingLoc(Loc);
   assert(CurBuf != -1 && "Invalid or unspecified location!");
   
-  PrintIncludeStack(getBufferInfo(CurBuf).IncludeLoc, OS);
-  
   MemoryBuffer *CurMB = getBufferInfo(CurBuf).Buffer;
   
   
@@ -122,12 +124,21 @@ void SourceMgr::PrintMessage(SMLoc Loc, const std::string &Msg,
   }
   PrintedMsg += Msg;
   
-  
   // Print out the line.
-  SMDiagnostic(CurMB->getBufferIdentifier(), FindLineNumber(Loc, CurBuf),
-               Loc.getPointer()-LineStart, PrintedMsg,
-               std::string(LineStart, LineEnd)).Print(0, OS);
-  
+  return SMDiagnostic(CurMB->getBufferIdentifier(), FindLineNumber(Loc, CurBuf),
+                      Loc.getPointer()-LineStart, PrintedMsg,
+                      std::string(LineStart, LineEnd));
+}
+
+void SourceMgr::PrintMessage(SMLoc Loc, const std::string &Msg, 
+                             const char *Type) const {
+  raw_ostream &OS = errs();
+
+  int CurBuf = FindBufferContainingLoc(Loc);
+  assert(CurBuf != -1 && "Invalid or unspecified location!");
+  PrintIncludeStack(getBufferInfo(CurBuf).IncludeLoc, OS);
+
+  GetMessage(Loc, Msg, Type).Print(0, OS);
 }
 
 //===----------------------------------------------------------------------===//