//
//===----------------------------------------------------------------------===//
-#include <algorithm>
-#include <sstream>
-
#include "TGParser.h"
#include "Record.h"
#include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/Streams.h"
+#include <algorithm>
+#include <sstream>
using namespace llvm;
//===----------------------------------------------------------------------===//
namespace llvm {
struct SubClassReference {
- TGLoc RefLoc;
+ SMLoc RefLoc;
Record *Rec;
std::vector<Init*> TemplateArgs;
SubClassReference() : Rec(0) {}
};
struct SubMultiClassReference {
- TGLoc RefLoc;
+ SMLoc RefLoc;
MultiClass *MC;
std::vector<Init*> TemplateArgs;
SubMultiClassReference() : MC(0) {}
};
void SubMultiClassReference::dump() const {
- cerr << "Multiclass:\n";
+ errs() << "Multiclass:\n";
MC->dump();
- cerr << "Template args:\n";
+ errs() << "Template args:\n";
for (std::vector<Init *>::const_iterator i = TemplateArgs.begin(),
iend = TemplateArgs.end();
i != iend;
} // end namespace llvm
-bool TGParser::AddValue(Record *CurRec, TGLoc Loc, const RecordVal &RV) {
+bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
if (CurRec == 0)
CurRec = &CurMultiClass->Rec;
/// SetValue -
/// Return true on error, false on success.
-bool TGParser::SetValue(Record *CurRec, TGLoc Loc, const std::string &ValName,
+bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName,
const std::vector<unsigned> &BitList, Init *V) {
if (!V) return false;
if (Lex.getCode() != tgtok::less)
return false;
- TGLoc StartLoc = Lex.getLoc();
+ SMLoc StartLoc = Lex.getLoc();
Lex.Lex(); // eat the '<'
// Parse the range list.
if (Lex.getCode() != tgtok::l_brace)
return false;
- TGLoc StartLoc = Lex.getLoc();
+ SMLoc StartLoc = Lex.getLoc();
Lex.Lex(); // eat the '{'
// Parse the range list.
Init *TGParser::ParseIDValue(Record *CurRec) {
assert(Lex.getCode() == tgtok::Id && "Expected ID in ParseIDValue");
std::string Name = Lex.getCurStrVal();
- TGLoc Loc = Lex.getLoc();
+ SMLoc Loc = Lex.getLoc();
Lex.Lex();
return ParseIDValue(CurRec, Name, Loc);
}
/// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID
/// has already been read.
Init *TGParser::ParseIDValue(Record *CurRec,
- const std::string &Name, TGLoc NameLoc) {
+ const std::string &Name, SMLoc NameLoc) {
if (CurRec) {
if (const RecordVal *RV = CurRec->getValue(Name))
return new VarInit(Name, RV->getType());
case tgtok::XSRL:
case tgtok::XSHL:
case tgtok::XStrConcat:
- case tgtok::XRegMatch:
case tgtok::XNameConcat: { // Value ::= !binop '(' Value ',' Value ')'
BinOpInit::BinaryOp Code;
RecTy *Type = 0;
Code = BinOpInit::STRCONCAT;
Type = new StringRecTy();
break;
- case tgtok::XRegMatch:
- Lex.Lex(); // eat the operation
- Code = BinOpInit::REGMATCH;
- Type = new IntRecTy();
- break;
case tgtok::XNameConcat:
Lex.Lex(); // eat the operation
Code = BinOpInit::NAMECONCAT;
R = new CodeInit(Lex.getCurStrVal()); Lex.Lex(); break;
case tgtok::question: R = new UnsetInit(); Lex.Lex(); break;
case tgtok::Id: {
- TGLoc NameLoc = Lex.getLoc();
+ SMLoc NameLoc = Lex.getLoc();
std::string Name = Lex.getCurStrVal();
if (Lex.Lex() != tgtok::less) // consume the Id.
return ParseIDValue(CurRec, Name, NameLoc); // Value ::= IDValue
return new DefInit(NewRec);
}
case tgtok::l_brace: { // Value ::= '{' ValueList '}'
- TGLoc BraceLoc = Lex.getLoc();
+ SMLoc BraceLoc = Lex.getLoc();
Lex.Lex(); // eat the '{'
std::vector<Init*> Vals;
case tgtok::XSRL:
case tgtok::XSHL:
case tgtok::XStrConcat:
- case tgtok::XRegMatch:
case tgtok::XNameConcat: // Value ::= !binop '(' Value ',' Value ')'
case tgtok::XIf:
case tgtok::XForEach:
switch (Lex.getCode()) {
default: return Result;
case tgtok::l_brace: {
- TGLoc CurlyLoc = Lex.getLoc();
+ SMLoc CurlyLoc = Lex.getLoc();
Lex.Lex(); // eat the '{'
std::vector<unsigned> Ranges = ParseRangeList();
if (Ranges.empty()) return 0;
break;
}
case tgtok::l_square: {
- TGLoc SquareLoc = Lex.getLoc();
+ SMLoc SquareLoc = Lex.getLoc();
Lex.Lex(); // eat the '['
std::vector<unsigned> Ranges = ParseRangeList();
if (Ranges.empty()) return 0;
std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, RecTy *EltTy) {
std::vector<Init*> Result;
RecTy *ItemType = EltTy;
- int ArgN = 0;
+ unsigned int ArgN = 0;
if (ArgsRec != 0 && EltTy == 0) {
const std::vector<std::string> &TArgs = ArgsRec->getTemplateArgs();
const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]);
if (ArgsRec != 0 && EltTy == 0) {
const std::vector<std::string> &TArgs = ArgsRec->getTemplateArgs();
+ if (ArgN >= TArgs.size()) {
+ TokError("too many template arguments");
+ return std::vector<Init*>();
+ }
const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]);
assert(RV && "Template argument record not found??");
ItemType = RV->getType();
return "";
}
- TGLoc IdLoc = Lex.getLoc();
+ SMLoc IdLoc = Lex.getLoc();
std::string DeclName = Lex.getCurStrVal();
Lex.Lex();
// If a value is present, parse it.
if (Lex.getCode() == tgtok::equal) {
Lex.Lex();
- TGLoc ValLoc = Lex.getLoc();
+ SMLoc ValLoc = Lex.getLoc();
Init *Val = ParseValue(CurRec, Type);
if (Val == 0 ||
SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val))
if (Lex.Lex() != tgtok::Id)
return TokError("expected field identifier after let");
- TGLoc IdLoc = Lex.getLoc();
+ SMLoc IdLoc = Lex.getLoc();
std::string FieldName = Lex.getCurStrVal();
Lex.Lex(); // eat the field name.
/// DefInst ::= DEF ObjectName ObjectBody
///
llvm::Record *TGParser::ParseDef(MultiClass *CurMultiClass) {
- TGLoc DefLoc = Lex.getLoc();
+ SMLoc DefLoc = Lex.getLoc();
assert(Lex.getCode() == tgtok::Def && "Unknown tok");
Lex.Lex(); // Eat the 'def' token.
return std::vector<LetRecord>();
}
std::string Name = Lex.getCurStrVal();
- TGLoc NameLoc = Lex.getLoc();
+ SMLoc NameLoc = Lex.getLoc();
Lex.Lex(); // Eat the identifier.
// Check for an optional RangeList.
if (ParseObject())
return true;
} else { // Object ::= LETCommand '{' ObjectList '}'
- TGLoc BraceLoc = Lex.getLoc();
+ SMLoc BraceLoc = Lex.getLoc();
// Otherwise, this is a group let.
Lex.Lex(); // eat the '{'.
if (Lex.Lex() != tgtok::Id) // eat the defm.
return TokError("expected identifier after defm");
- TGLoc DefmPrefixLoc = Lex.getLoc();
+ SMLoc DefmPrefixLoc = Lex.getLoc();
std::string DefmPrefix = Lex.getCurStrVal();
if (Lex.Lex() != tgtok::colon)
return TokError("expected ':' after defm identifier");
// eat the colon.
Lex.Lex();
- TGLoc SubClassLoc = Lex.getLoc();
+ SMLoc SubClassLoc = Lex.getLoc();
SubClassReference Ref = ParseSubClassReference(0, true);
while (1) {