tblgen/AsmMatcher: Always emit the match function as 'MatchInstructionImpl',

[oota-llvm.git] / utils / TableGen / TGParser.h

diff --git a/utils/TableGen/TGParser.h b/utils/TableGen/TGParser.h
index a5435afacf29ad9f99d3c3422380f3d0265a32df..0aee931423a618997ca2fd428690a5dbd1dc58e5 100644 (file)
--- a/utils/TableGen/TGParser.h
+++ b/utils/TableGen/TGParser.h
@@ -15,23 +15,25 @@
 #define TGPARSER_H
 
 #include "TGLexer.h"
+#include "llvm/Support/SourceMgr.h"
 #include <map>
 
 namespace llvm {
   class Record;
   class RecordVal;
-  class RecTy;
-  class Init;
+  struct RecTy;
+  struct Init;
   struct MultiClass;
   struct SubClassReference;
+  struct SubMultiClassReference;
   
   struct LetRecord {
     std::string Name;
     std::vector<unsigned> Bits;
     Init *Value;
-    TGLexer::LocTy Loc;
+    SMLoc Loc;
     LetRecord(const std::string &N, const std::vector<unsigned> &B, Init *V,
-              TGLexer::LocTy L)
+              SMLoc L)
       : Name(N), Bits(B), Value(V), Loc(L) {
     }
   };
@@ -45,17 +47,13 @@ class TGParser {
   /// current value.
   MultiClass *CurMultiClass;
 public:
-  typedef TGLexer::LocTy LocTy;
+  TGParser(SourceMgr &SrcMgr) : Lex(SrcMgr), CurMultiClass(0) {}
   
-  TGParser(MemoryBuffer *StartBuf) : Lex(StartBuf), CurMultiClass(0) {}
-  
-  void setIncludeDirs(const std::vector<std::string> &D){Lex.setIncludeDirs(D);}
-
   /// ParseFile - Main entrypoint for parsing a tblgen file.  These parser
   /// routines return true on error, or false on success.
   bool ParseFile();
   
-  bool Error(LocTy L, const std::string &Msg) const {
+  bool Error(SMLoc L, const std::string &Msg) const {
     Lex.PrintError(L, Msg);
     return true;
   }
@@ -63,22 +61,23 @@ public:
     return Error(Lex.getLoc(), Msg);
   }
 private:  // Semantic analysis methods.
-  bool AddValue(Record *TheRec, LocTy Loc, const RecordVal &RV);
-  bool SetValue(Record *TheRec, LocTy Loc, const std::string &ValName, 
+  bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV);
+  bool SetValue(Record *TheRec, SMLoc Loc, const std::string &ValName, 
                 const std::vector<unsigned> &BitList, Init *V);
-  bool AddSubClass(Record *Rec, class SubClassReference &SubClass);
+  bool AddSubClass(Record *Rec, SubClassReference &SubClass);
+  bool AddSubMultiClass(MultiClass *CurMC,
+                        SubMultiClassReference &SubMultiClass);
 
 private:  // Parser methods.
-  bool ParseObjectList();
-  bool ParseObject();
+  bool ParseObjectList(MultiClass *MC = 0);
+  bool ParseObject(MultiClass *MC);
   bool ParseClass();
   bool ParseMultiClass();
-  bool ParseMultiClassDef(MultiClass *CurMC);
-  bool ParseDefm();
-  bool ParseTopLevelLet();
+  bool ParseDefm(MultiClass *CurMultiClass);
+  bool ParseDef(MultiClass *CurMultiClass);
+  bool ParseTopLevelLet(MultiClass *CurMultiClass);
   std::vector<LetRecord> ParseLetList();
 
-  Record *ParseDef(MultiClass *CurMultiClass);
   bool ParseObjectBody(Record *CurRec);
   bool ParseBody(Record *CurRec);
   bool ParseBodyItem(Record *CurRec);
@@ -87,20 +86,24 @@ private:  // Parser methods.
   std::string ParseDeclaration(Record *CurRec, bool ParsingTemplateArgs);
 
   SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm);
+  SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC);
 
   Init *ParseIDValue(Record *CurRec);
-  Init *ParseIDValue(Record *CurRec, const std::string &Name, LocTy NameLoc);
-  Init *ParseSimpleValue(Record *CurRec);
-  Init *ParseValue(Record *CurRec);
-  std::vector<Init*> ParseValueList(Record *CurRec);
+  Init *ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc);
+  Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0);
+  Init *ParseValue(Record *CurRec, RecTy *ItemType = 0);
+  std::vector<Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0, RecTy *EltTy = 0);
   std::vector<std::pair<llvm::Init*, std::string> > ParseDagArgList(Record *);
   bool ParseOptionalRangeList(std::vector<unsigned> &Ranges);
   bool ParseOptionalBitList(std::vector<unsigned> &Ranges);
   std::vector<unsigned> ParseRangeList();
   bool ParseRangePiece(std::vector<unsigned> &Ranges);
   RecTy *ParseType();
+  Init *ParseOperation(Record *CurRec);
+  RecTy *ParseOperatorType();
   std::string ParseObjectName();
   Record *ParseClassID();
+  MultiClass *ParseMultiClassID();
   Record *ParseDefmID();
 };