X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=utils%2FTableGen%2FRecord.cpp;h=c5f0565749979bdf4637e1ac9b527c4a397d621d;hb=603d78c9de31b15deee3f01c59083cf759f00897;hp=d48d987a85a5ccf65e79eda45b027c011f6cacc8;hpb=ade0de91236a5967e323a810b21bda4b0425642f;p=oota-llvm.git diff --git a/utils/TableGen/Record.cpp b/utils/TableGen/Record.cpp index d48d987a85a..c5f05657499 100644 --- a/utils/TableGen/Record.cpp +++ b/utils/TableGen/Record.cpp @@ -1,9 +1,18 @@ //===- Record.cpp - Record implementation ---------------------------------===// // +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// // //===----------------------------------------------------------------------===// #include "Record.h" +#include "llvm/Support/DataTypes.h" +using namespace llvm; //===----------------------------------------------------------------------===// // Type implementations @@ -16,12 +25,15 @@ Init *BitRecTy::convertValue(BitsInit *BI) { return BI->getBit(0); } +bool BitRecTy::baseClassOf(const BitsRecTy *RHS) const { + return RHS->getNumBits() == 1; +} + Init *BitRecTy::convertValue(IntInit *II) { int Val = II->getValue(); if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit! - delete II; - - return new BitInit(Val != 0); + + return new BitInit(Val != 0); } Init *BitRecTy::convertValue(TypedInit *VI) { @@ -49,12 +61,20 @@ Init *BitsRecTy::convertValue(BitInit *UI) { // appropriate bits... // Init *BitsRecTy::convertValue(IntInit *II) { - int Value = II->getValue(); - delete II; + int64_t Value = II->getValue(); + // Make sure this bitfield is large enough to hold the integer value... + if (Value >= 0) { + if (Value & ~((1LL << Size)-1)) + return 0; + } else { + if ((Value >> Size) != -1 || ((Value & (1 << (Size-1))) == 0)) + return 0; + } BitsInit *Ret = new BitsInit(Size); for (unsigned i = 0; i != Size; ++i) Ret->setBit(i, new BitInit(Value & (1 << i))); + return Ret; } @@ -70,7 +90,7 @@ Init *BitsRecTy::convertValue(TypedInit *VI) { if (BRT->Size == Size) { BitsInit *Ret = new BitsInit(Size); for (unsigned i = 0; i != Size; ++i) - Ret->setBit(i, new VarBitInit(VI, i)); + Ret->setBit(i, new VarBitInit(VI, i)); return Ret; } if (Size == 1 && dynamic_cast(VI->getType())) { @@ -78,13 +98,17 @@ Init *BitsRecTy::convertValue(TypedInit *VI) { Ret->setBit(0, VI); return Ret; } - + return 0; } +Init *IntRecTy::convertValue(BitInit *BI) { + return new IntInit(BI->getValue()); +} + Init *IntRecTy::convertValue(BitsInit *BI) { int Result = 0; - for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) + for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) if (BitInit *Bit = dynamic_cast(BI->getBit(i))) { Result |= Bit->getValue() << i; } else { @@ -94,7 +118,7 @@ Init *IntRecTy::convertValue(BitsInit *BI) { } Init *IntRecTy::convertValue(TypedInit *TI) { - if (dynamic_cast(TI->getType())) + if (TI->getType()->typeIsConvertibleTo(this)) return TI; // Accept variable if already of the right type! return 0; } @@ -106,18 +130,44 @@ Init *StringRecTy::convertValue(TypedInit *TI) { } void ListRecTy::print(std::ostream &OS) const { - OS << "list<" << Class->getName() << ">"; + OS << "list<" << *Ty << ">"; } Init *ListRecTy::convertValue(ListInit *LI) { + std::vector Elements; + // Verify that all of the elements of the list are subclasses of the - // appopriate class! + // appropriate class! for (unsigned i = 0, e = LI->getSize(); i != e; ++i) - if (!LI->getElement(i)->isSubClassOf(Class)) + if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty)) + Elements.push_back(CI); + else return 0; - return LI; + + return new ListInit(Elements); } +Init *ListRecTy::convertValue(TypedInit *TI) { + // Ensure that TI is compatible with our class. + if (ListRecTy *LRT = dynamic_cast(TI->getType())) + if (LRT->getElementType()->typeIsConvertibleTo(getElementType())) + return TI; + return 0; +} + +Init *CodeRecTy::convertValue(TypedInit *TI) { + if (TI->getType()->typeIsConvertibleTo(this)) + return TI; + return 0; +} + +Init *DagRecTy::convertValue(TypedInit *TI) { + if (TI->getType()->typeIsConvertibleTo(this)) + return TI; + return 0; +} + + void RecordRecTy::print(std::ostream &OS) const { OS << Rec->getName(); } @@ -129,6 +179,20 @@ Init *RecordRecTy::convertValue(DefInit *DI) { return DI; } +Init *RecordRecTy::convertValue(TypedInit *TI) { + // Ensure that TI is compatible with Rec. + if (RecordRecTy *RRT = dynamic_cast(TI->getType())) + if (RRT->getRecord()->isSubClassOf(getRecord()) || + RRT->getRecord() == getRecord()) + return TI; + return 0; +} + +bool RecordRecTy::baseClassOf(const RecordRecTy *RHS) const { + return Rec == RHS->getRecord() || RHS->getRecord()->isSubClassOf(Rec); +} + + //===----------------------------------------------------------------------===// // Initializer implementations //===----------------------------------------------------------------------===// @@ -155,7 +219,10 @@ void BitsInit::print(std::ostream &OS) const { OS << "{ "; for (unsigned i = 0, e = getNumBits(); i != e; ++i) { if (i) OS << ", "; - getBit(e-i-1)->print(OS); + if (Init *Bit = getBit(e-i-1)) + Bit->print(OS); + else + OS << "*"; } OS << " }"; } @@ -163,7 +230,7 @@ void BitsInit::print(std::ostream &OS) const { bool BitsInit::printInHex(std::ostream &OS) const { // First, attempt to convert the value into an integer value... int Result = 0; - for (unsigned i = 0, e = getNumBits(); i != e; ++i) + for (unsigned i = 0, e = getNumBits(); i != e; ++i) if (BitInit *Bit = dynamic_cast(getBit(i))) { Result |= Bit->getValue() << i; } else { @@ -198,14 +265,17 @@ bool BitsInit::printAsVariable(std::ostream &OS) const { } bool BitsInit::printAsUnset(std::ostream &OS) const { - for (unsigned i = 0, e = getNumBits(); i != e; ++i) + for (unsigned i = 0, e = getNumBits(); i != e; ++i) if (!dynamic_cast(getBit(i))) return true; OS << "?"; return false; } -Init *BitsInit::resolveReferences(Record &R) { +// resolveReferences - If there are any field references that refer to fields +// that have been filled in, we can propagate the values now. +// +Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) { bool Changed = false; BitsInit *New = new BitsInit(getNumBits()); @@ -215,7 +285,7 @@ Init *BitsInit::resolveReferences(Record &R) { do { B = CurBit; - CurBit = CurBit->resolveReferences(R); + CurBit = CurBit->resolveReferences(R, RV); Changed |= B != CurBit; } while (B != CurBit); New->setBit(i, CurBit); @@ -227,6 +297,21 @@ Init *BitsInit::resolveReferences(Record &R) { return this; } +Init *IntInit::getBinaryOp(BinaryOp Op, Init *RHS) { + IntInit *RHSi = dynamic_cast(RHS); + if (RHSi == 0) return 0; + + int NewValue; + switch (Op) { + default: assert(0 && "Unknown binop"); + case SHL: NewValue = Value << RHSi->getValue(); break; + case SRA: NewValue = Value >> RHSi->getValue(); break; + case SRL: NewValue = (unsigned)Value >> (unsigned)RHSi->getValue(); break; + } + return new IntInit(NewValue); +} + + Init *IntInit::convertInitializerBitRange(const std::vector &Bits) { BitsInit *BI = new BitsInit(Bits.size()); @@ -240,16 +325,48 @@ Init *IntInit::convertInitializerBitRange(const std::vector &Bits) { return BI; } +Init *ListInit::convertInitListSlice(const std::vector &Elements) { + std::vector Vals; + for (unsigned i = 0, e = Elements.size(); i != e; ++i) { + if (Elements[i] >= getSize()) + return 0; + Vals.push_back(getElement(Elements[i])); + } + return new ListInit(Vals); +} + +Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) { + std::vector Resolved; + Resolved.reserve(getSize()); + bool Changed = false; + + for (unsigned i = 0, e = getSize(); i != e; ++i) { + Init *E; + Init *CurElt = getElement(i); + + do { + E = CurElt; + CurElt = CurElt->resolveReferences(R, RV); + Changed |= E != CurElt; + } while (E != CurElt); + Resolved.push_back(E); + } + + if (Changed) + return new ListInit(Resolved); + return this; +} + void ListInit::print(std::ostream &OS) const { OS << "["; - for (unsigned i = 0, e = Records.size(); i != e; ++i) { + for (unsigned i = 0, e = Values.size(); i != e; ++i) { if (i) OS << ", "; - OS << Records[i]->getName(); + OS << *Values[i]; } OS << "]"; } -Init *VarInit::convertInitializerBitRange(const std::vector &Bits) { +Init *TypedInit::convertInitializerBitRange(const std::vector &Bits) { BitsRecTy *T = dynamic_cast(getType()); if (T == 0) return 0; // Cannot subscript a non-bits variable... unsigned NumBits = T->getNumBits(); @@ -265,23 +382,58 @@ Init *VarInit::convertInitializerBitRange(const std::vector &Bits) { return BI; } -Init *VarInit::resolveBitReference(Record &R, unsigned Bit) { - if (R.isTemplateArg(getName())) - return this; +Init *TypedInit::convertInitListSlice(const std::vector &Elements) { + ListRecTy *T = dynamic_cast(getType()); + if (T == 0) return 0; // Cannot subscript a non-list variable... + + if (Elements.size() == 1) + return new VarListElementInit(this, Elements[0]); + + std::vector ListInits; + ListInits.reserve(Elements.size()); + for (unsigned i = 0, e = Elements.size(); i != e; ++i) + ListInits.push_back(new VarListElementInit(this, Elements[i])); + return new ListInit(ListInits); +} + + +Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV, + unsigned Bit) { + if (R.isTemplateArg(getName())) return 0; + if (IRV && IRV->getName() != getName()) return 0; RecordVal *RV = R.getValue(getName()); assert(RV && "Reference to a non-existant variable?"); assert(dynamic_cast(RV->getValue())); BitsInit *BI = (BitsInit*)RV->getValue(); - + assert(Bit < BI->getNumBits() && "Bit reference out of range!"); Init *B = BI->getBit(Bit); if (!dynamic_cast(B)) // If the bit is not set... return B; // Replace the VarBitInit with it. - return this; + return 0; +} + +Init *VarInit::resolveListElementReference(Record &R, const RecordVal *IRV, + unsigned Elt) { + if (R.isTemplateArg(getName())) return 0; + if (IRV && IRV->getName() != getName()) return 0; + + RecordVal *RV = R.getValue(getName()); + assert(RV && "Reference to a non-existant variable?"); + ListInit *LI = dynamic_cast(RV->getValue()); + assert(LI && "Invalid list element!"); + + if (Elt >= LI->getSize()) + return 0; // Out of range reference. + Init *E = LI->getElement(Elt); + if (!dynamic_cast(E)) // If the element is set + return E; // Replace the VarListElementInit with it. + return 0; } + RecTy *VarInit::getFieldType(const std::string &FieldName) const { if (RecordRecTy *RTy = dynamic_cast(getType())) if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName)) @@ -291,23 +443,57 @@ RecTy *VarInit::getFieldType(const std::string &FieldName) const { Init *VarInit::getFieldInit(Record &R, const std::string &FieldName) const { if (RecordRecTy *RTy = dynamic_cast(getType())) - if (const RecordVal *RV = R.getValue(VarName)) - if (Init *I = RV->getValue()->getFieldInit(R, FieldName)) + if (const RecordVal *RV = R.getValue(VarName)) { + Init *TheInit = RV->getValue(); + assert(TheInit != this && "Infinite loop detected!"); + if (Init *I = TheInit->getFieldInit(R, FieldName)) return I; else - return (Init*)this; + return 0; + } return 0; } +/// resolveReferences - This method is used by classes that refer to other +/// variables which may not be defined at the time they expression is formed. +/// If a value is set for the variable later, this method will be called on +/// users of the value to allow the value to propagate out. +/// +Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) { + if (RecordVal *Val = R.getValue(VarName)) + if (RV == Val || (RV == 0 && !dynamic_cast(Val->getValue()))) + return Val->getValue(); + return this; +} -Init *VarBitInit::resolveReferences(Record &R) { - Init *I = getVariable()->resolveBitReference(R, getBitNum()); - if (I != getVariable()) +Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) { + if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum())) return I; return this; } +Init *VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) { + if (Init *I = getVariable()->resolveListElementReference(R, RV, + getElementNum())) + return I; + return this; +} + +Init *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV, + unsigned Bit) { + // FIXME: This should be implemented, to support references like: + // bit B = AA[0]{1}; + return 0; +} + +Init *VarListElementInit:: +resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) { + // FIXME: This should be implemented, to support references like: + // int B = AA[0][1]; + return 0; +} + RecTy *DefInit::getFieldType(const std::string &FieldName) const { if (const RecordVal *RV = Def->getValue(FieldName)) return RV->getType(); @@ -323,37 +509,64 @@ void DefInit::print(std::ostream &OS) const { OS << Def->getName(); } -Init *FieldInit::convertInitializerBitRange(const std::vector &Bits) { - BitsRecTy *T = dynamic_cast(getType()); - if (T == 0) return 0; // Cannot subscript a non-bits field... - unsigned NumBits = T->getNumBits(); +Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV, + unsigned Bit) { + if (Init *BitsVal = Rec->getFieldInit(R, FieldName)) + if (BitsInit *BI = dynamic_cast(BitsVal)) { + assert(Bit < BI->getNumBits() && "Bit reference out of range!"); + Init *B = BI->getBit(Bit); - BitsInit *BI = new BitsInit(Bits.size()); - for (unsigned i = 0, e = Bits.size(); i != e; ++i) { - if (Bits[i] >= NumBits) { - delete BI; - return 0; + if (dynamic_cast(B)) // If the bit is set... + return B; // Replace the VarBitInit with it. } - BI->setBit(i, new VarBitInit(this, Bits[i])); - } - return BI; + return 0; } -Init *FieldInit::resolveBitReference(Record &R, unsigned Bit) { - Init *BitsVal = Rec->getFieldInit(R, FieldName); - assert(BitsVal && "No initializer found!"); +Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) { + if (Init *ListVal = Rec->getFieldInit(R, FieldName)) + if (ListInit *LI = dynamic_cast(ListVal)) { + if (Elt >= LI->getSize()) return 0; + Init *E = LI->getElement(Elt); - if (BitsInit *BI = dynamic_cast(BitsVal)) { - assert(Bit < BI->getNumBits() && "Bit reference out of range!"); - Init *B = BI->getBit(Bit); - - if (dynamic_cast(B)) // If the bit is set... - return B; // Replace the VarBitInit with it. + if (!dynamic_cast(E)) // If the bit is set... + return E; // Replace the VarListElementInit with it. + } + return 0; +} + +Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) { + Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; + + Init *BitsVal = NewRec->getFieldInit(R, FieldName); + if (BitsVal) { + Init *BVR = BitsVal->resolveReferences(R, RV); + return BVR->isComplete() ? BVR : this; + } + + if (NewRec != Rec) { + dump(); + NewRec->dump(); std::cerr << "\n"; + return new FieldInit(NewRec, FieldName); } return this; } +void DagInit::print(std::ostream &OS) const { + OS << "(" << NodeTypeDef->getName(); + if (Args.size()) { + OS << " " << *Args[0]; + if (!ArgNames[0].empty()) OS << ":$" << ArgNames[0]; + for (unsigned i = 1, e = Args.size(); i != e; ++i) { + OS << ", " << *Args[i]; + if (!ArgNames[i].empty()) OS << ":$" << ArgNames[i]; + } + } + OS << ")"; +} + + //===----------------------------------------------------------------------===// // Other implementations //===----------------------------------------------------------------------===// @@ -369,23 +582,39 @@ void RecordVal::dump() const { std::cerr << *this; } void RecordVal::print(std::ostream &OS, bool PrintSem) const { if (getPrefix()) OS << "field "; OS << *getType() << " " << getName(); - if (getValue()) { + + if (getValue()) OS << " = " << *getValue(); - } + if (PrintSem) OS << ";\n"; } -// resolveReferences - If there are any field references that refer to fields -// that have been filled in, we can propagate the values now. -// -void Record::resolveReferences() { - for (unsigned i = 0, e = Values.size(); i != e; ++i) - Values[i].setValue(Values[i].getValue()->resolveReferences(*this)); +void Record::setName(const std::string &Name) { + if (Records.getDef(getName()) == this) { + Records.removeDef(getName()); + this->Name = Name; + Records.addDef(this); + } else { + Records.removeClass(getName()); + this->Name = Name; + Records.addClass(this); + } } +/// resolveReferencesTo - If anything in this record refers to RV, replace the +/// reference to RV with the RHS of RV. If RV is null, we resolve all possible +/// references. +void Record::resolveReferencesTo(const RecordVal *RV) { + for (unsigned i = 0, e = Values.size(); i != e; ++i) { + if (Init *V = Values[i].getValue()) + Values[i].setValue(V->resolveReferences(*this, RV)); + } +} + + void Record::dump() const { std::cerr << *this; } -std::ostream &operator<<(std::ostream &OS, const Record &R) { +std::ostream &llvm::operator<<(std::ostream &OS, const Record &R) { OS << R.getName(); const std::vector &TArgs = R.getTemplateArgs(); @@ -420,19 +649,176 @@ std::ostream &operator<<(std::ostream &OS, const Record &R) { return OS << "}\n"; } +/// getValueInit - Return the initializer for a value with the specified name, +/// or throw an exception if the field does not exist. +/// +Init *Record::getValueInit(const std::string &FieldName) const { + const RecordVal *R = getValue(FieldName); + if (R == 0 || R->getValue() == 0) + throw "Record `" + getName() + "' does not have a field named `" + + FieldName + "'!\n"; + return R->getValue(); +} + + +/// getValueAsString - This method looks up the specified field and returns its +/// value as a string, throwing an exception if the field does not exist or if +/// the value is not a string. +/// +std::string Record::getValueAsString(const std::string &FieldName) const { + const RecordVal *R = getValue(FieldName); + if (R == 0 || R->getValue() == 0) + throw "Record `" + getName() + "' does not have a field named `" + + FieldName + "'!\n"; + + if (const StringInit *SI = dynamic_cast(R->getValue())) + return SI->getValue(); + throw "Record `" + getName() + "', field `" + FieldName + + "' does not have a string initializer!"; +} + +/// getValueAsBitsInit - This method looks up the specified field and returns +/// its value as a BitsInit, throwing an exception if the field does not exist +/// or if the value is not the right type. +/// +BitsInit *Record::getValueAsBitsInit(const std::string &FieldName) const { + const RecordVal *R = getValue(FieldName); + if (R == 0 || R->getValue() == 0) + throw "Record `" + getName() + "' does not have a field named `" + + FieldName + "'!\n"; + + if (BitsInit *BI = dynamic_cast(R->getValue())) + return BI; + throw "Record `" + getName() + "', field `" + FieldName + + "' does not have a BitsInit initializer!"; +} + +/// getValueAsListInit - This method looks up the specified field and returns +/// its value as a ListInit, throwing an exception if the field does not exist +/// or if the value is not the right type. +/// +ListInit *Record::getValueAsListInit(const std::string &FieldName) const { + const RecordVal *R = getValue(FieldName); + if (R == 0 || R->getValue() == 0) + throw "Record `" + getName() + "' does not have a field named `" + + FieldName + "'!\n"; + + if (ListInit *LI = dynamic_cast(R->getValue())) + return LI; + throw "Record `" + getName() + "', field `" + FieldName + + "' does not have a list initializer!"; +} + +/// getValueAsInt - This method looks up the specified field and returns its +/// value as an int, throwing an exception if the field does not exist or if +/// the value is not the right type. +/// +int Record::getValueAsInt(const std::string &FieldName) const { + const RecordVal *R = getValue(FieldName); + if (R == 0 || R->getValue() == 0) + throw "Record `" + getName() + "' does not have a field named `" + + FieldName + "'!\n"; + + if (IntInit *II = dynamic_cast(R->getValue())) + return II->getValue(); + throw "Record `" + getName() + "', field `" + FieldName + + "' does not have a list initializer!"; +} + +/// getValueAsDef - This method looks up the specified field and returns its +/// value as a Record, throwing an exception if the field does not exist or if +/// the value is not the right type. +/// +Record *Record::getValueAsDef(const std::string &FieldName) const { + const RecordVal *R = getValue(FieldName); + if (R == 0 || R->getValue() == 0) + throw "Record `" + getName() + "' does not have a field named `" + + FieldName + "'!\n"; + + if (DefInit *DI = dynamic_cast(R->getValue())) + return DI->getDef(); + throw "Record `" + getName() + "', field `" + FieldName + + "' does not have a list initializer!"; +} + +/// getValueAsBit - This method looks up the specified field and returns its +/// value as a bit, throwing an exception if the field does not exist or if +/// the value is not the right type. +/// +bool Record::getValueAsBit(const std::string &FieldName) const { + const RecordVal *R = getValue(FieldName); + if (R == 0 || R->getValue() == 0) + throw "Record `" + getName() + "' does not have a field named `" + + FieldName + "'!\n"; + + if (BitInit *BI = dynamic_cast(R->getValue())) + return BI->getValue(); + throw "Record `" + getName() + "', field `" + FieldName + + "' does not have a bit initializer!"; +} + +/// getValueAsDag - This method looks up the specified field and returns its +/// value as an Dag, throwing an exception if the field does not exist or if +/// the value is not the right type. +/// +DagInit *Record::getValueAsDag(const std::string &FieldName) const { + const RecordVal *R = getValue(FieldName); + if (R == 0 || R->getValue() == 0) + throw "Record `" + getName() + "' does not have a field named `" + + FieldName + "'!\n"; + + if (DagInit *DI = dynamic_cast(R->getValue())) + return DI; + throw "Record `" + getName() + "', field `" + FieldName + + "' does not have a dag initializer!"; +} + +std::string Record::getValueAsCode(const std::string &FieldName) const { + const RecordVal *R = getValue(FieldName); + if (R == 0 || R->getValue() == 0) + throw "Record `" + getName() + "' does not have a field named `" + + FieldName + "'!\n"; + + if (const CodeInit *CI = dynamic_cast(R->getValue())) + return CI->getValue(); + throw "Record `" + getName() + "', field `" + FieldName + + "' does not have a code initializer!"; +} + + void RecordKeeper::dump() const { std::cerr << *this; } -std::ostream &operator<<(std::ostream &OS, const RecordKeeper &RK) { +std::ostream &llvm::operator<<(std::ostream &OS, const RecordKeeper &RK) { OS << "------------- Classes -----------------\n"; const std::map &Classes = RK.getClasses(); for (std::map::const_iterator I = Classes.begin(), - E = Classes.end(); I != E; ++I) + E = Classes.end(); I != E; ++I) OS << "class " << *I->second; - + OS << "------------- Defs -----------------\n"; const std::map &Defs = RK.getDefs(); for (std::map::const_iterator I = Defs.begin(), - E = Defs.end(); I != E; ++I) + E = Defs.end(); I != E; ++I) OS << "def " << *I->second; return OS; } + + +/// getAllDerivedDefinitions - This method returns all concrete definitions +/// that derive from the specified class name. If a class with the specified +/// name does not exist, an error is printed and true is returned. +std::vector +RecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const { + Record *Class = Records.getClass(ClassName); + if (!Class) + throw "ERROR: Couldn't find the `" + ClassName + "' class!\n"; + + std::vector Defs; + for (std::map::const_iterator I = getDefs().begin(), + E = getDefs().end(); I != E; ++I) + if (I->second->isSubClassOf(Class)) + Defs.push_back(I->second); + + return Defs; +} +