[llvm] r205830 - [C++11] Make use of 'nullptr' in TableGen library.
Craig Topper
craig.topper at gmail.com
Tue Apr 8 21:50:04 PDT 2014
Author: ctopper
Date: Tue Apr 8 23:50:04 2014
New Revision: 205830
URL: http://llvm.org/viewvc/llvm-project?rev=205830&view=rev
Log:
[C++11] Make use of 'nullptr' in TableGen library.
Modified:
llvm/trunk/include/llvm/TableGen/Record.h
llvm/trunk/lib/TableGen/Record.cpp
llvm/trunk/lib/TableGen/TGLexer.cpp
llvm/trunk/lib/TableGen/TGParser.cpp
Modified: llvm/trunk/include/llvm/TableGen/Record.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/TableGen/Record.h?rev=205830&r1=205829&r2=205830&view=diff
==============================================================================
--- llvm/trunk/include/llvm/TableGen/Record.h (original)
+++ llvm/trunk/include/llvm/TableGen/Record.h Tue Apr 8 23:50:04 2014
@@ -87,7 +87,7 @@ private:
public:
RecTyKind getRecTyKind() const { return Kind; }
- RecTy(RecTyKind K) : Kind(K), ListTy(0) {}
+ RecTy(RecTyKind K) : Kind(K), ListTy(nullptr) {}
virtual ~RecTy() {}
virtual std::string getAsString() const = 0;
@@ -102,12 +102,12 @@ public:
ListRecTy *getListTy();
public: // These methods should only be called from subclasses of Init
- virtual Init *convertValue( UnsetInit *UI) { return 0; }
- virtual Init *convertValue( BitInit *BI) { return 0; }
- virtual Init *convertValue( BitsInit *BI) { return 0; }
- virtual Init *convertValue( IntInit *II) { return 0; }
- virtual Init *convertValue(StringInit *SI) { return 0; }
- virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( UnsetInit *UI) { return nullptr; }
+ virtual Init *convertValue( BitInit *BI) { return nullptr; }
+ virtual Init *convertValue( BitsInit *BI) { return nullptr; }
+ virtual Init *convertValue( IntInit *II) { return nullptr; }
+ virtual Init *convertValue(StringInit *SI) { return nullptr; }
+ virtual Init *convertValue( ListInit *LI) { return nullptr; }
virtual Init *convertValue( UnOpInit *UI) {
return convertValue((TypedInit*)UI);
}
@@ -117,10 +117,10 @@ public: // These methods should only b
virtual Init *convertValue( TernOpInit *UI) {
return convertValue((TypedInit*)UI);
}
- virtual Init *convertValue(VarBitInit *VB) { return 0; }
- virtual Init *convertValue( DefInit *DI) { return 0; }
- virtual Init *convertValue( DagInit *DI) { return 0; }
- virtual Init *convertValue( TypedInit *TI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return nullptr; }
+ virtual Init *convertValue( DefInit *DI) { return nullptr; }
+ virtual Init *convertValue( DagInit *DI) { return nullptr; }
+ virtual Init *convertValue( TypedInit *TI) { return nullptr; }
virtual Init *convertValue( VarInit *VI) {
return convertValue((TypedInit*)VI);
}
@@ -154,11 +154,11 @@ public:
Init *convertValue( BitInit *BI) override { return (Init*)BI; }
Init *convertValue( BitsInit *BI) override;
Init *convertValue( IntInit *II) override;
- Init *convertValue(StringInit *SI) override { return 0; }
- Init *convertValue( ListInit *LI) override { return 0; }
+ Init *convertValue(StringInit *SI) override { return nullptr; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
Init *convertValue(VarBitInit *VB) override { return (Init*)VB; }
- Init *convertValue( DefInit *DI) override { return 0; }
- Init *convertValue( DagInit *DI) override { return 0; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( BinOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( TernOpInit *UI) override {return RecTy::convertValue(UI);}
@@ -193,11 +193,11 @@ public:
Init *convertValue( BitInit *UI) override;
Init *convertValue( BitsInit *BI) override;
Init *convertValue( IntInit *II) override;
- Init *convertValue(StringInit *SI) override { return 0; }
- Init *convertValue( ListInit *LI) override { return 0; }
- Init *convertValue(VarBitInit *VB) override { return 0; }
- Init *convertValue( DefInit *DI) override { return 0; }
- Init *convertValue( DagInit *DI) override { return 0; }
+ Init *convertValue(StringInit *SI) override { return nullptr; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( BinOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( TernOpInit *UI) override {return RecTy::convertValue(UI);}
@@ -230,11 +230,11 @@ public:
Init *convertValue( BitInit *BI) override;
Init *convertValue( BitsInit *BI) override;
Init *convertValue( IntInit *II) override { return (Init*)II; }
- Init *convertValue(StringInit *SI) override { return 0; }
- Init *convertValue( ListInit *LI) override { return 0; }
- Init *convertValue(VarBitInit *VB) override { return 0; }
- Init *convertValue( DefInit *DI) override { return 0; }
- Init *convertValue( DagInit *DI) override { return 0; }
+ Init *convertValue(StringInit *SI) override { return nullptr; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( BinOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( TernOpInit *UI) override {return RecTy::convertValue(UI);}
@@ -264,18 +264,18 @@ public:
static StringRecTy *get() { return &Shared; }
Init *convertValue( UnsetInit *UI) override { return (Init*)UI; }
- Init *convertValue( BitInit *BI) override { return 0; }
- Init *convertValue( BitsInit *BI) override { return 0; }
- Init *convertValue( IntInit *II) override { return 0; }
+ Init *convertValue( BitInit *BI) override { return nullptr; }
+ Init *convertValue( BitsInit *BI) override { return nullptr; }
+ Init *convertValue( IntInit *II) override { return nullptr; }
Init *convertValue(StringInit *SI) override { return (Init*)SI; }
- Init *convertValue( ListInit *LI) override { return 0; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
Init *convertValue( UnOpInit *BO) override;
Init *convertValue( BinOpInit *BO) override;
Init *convertValue( TernOpInit *BO) override {return RecTy::convertValue(BO);}
- Init *convertValue(VarBitInit *VB) override { return 0; }
- Init *convertValue( DefInit *DI) override { return 0; }
- Init *convertValue( DagInit *DI) override { return 0; }
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
Init *convertValue( TypedInit *TI) override;
Init *convertValue( VarInit *VI) override { return RecTy::convertValue(VI);}
Init *convertValue( FieldInit *FI) override { return RecTy::convertValue(FI);}
@@ -303,14 +303,14 @@ public:
RecTy *getElementType() const { return Ty; }
Init *convertValue( UnsetInit *UI) override { return (Init*)UI; }
- Init *convertValue( BitInit *BI) override { return 0; }
- Init *convertValue( BitsInit *BI) override { return 0; }
- Init *convertValue( IntInit *II) override { return 0; }
- Init *convertValue(StringInit *SI) override { return 0; }
+ Init *convertValue( BitInit *BI) override { return nullptr; }
+ Init *convertValue( BitsInit *BI) override { return nullptr; }
+ Init *convertValue( IntInit *II) override { return nullptr; }
+ Init *convertValue(StringInit *SI) override { return nullptr; }
Init *convertValue( ListInit *LI) override;
- Init *convertValue(VarBitInit *VB) override { return 0; }
- Init *convertValue( DefInit *DI) override { return 0; }
- Init *convertValue( DagInit *DI) override { return 0; }
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( BinOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( TernOpInit *UI) override{ return RecTy::convertValue(UI);}
@@ -340,13 +340,13 @@ public:
static DagRecTy *get() { return &Shared; }
Init *convertValue( UnsetInit *UI) override { return (Init*)UI; }
- Init *convertValue( BitInit *BI) override { return 0; }
- Init *convertValue( BitsInit *BI) override { return 0; }
- Init *convertValue( IntInit *II) override { return 0; }
- Init *convertValue(StringInit *SI) override { return 0; }
- Init *convertValue( ListInit *LI) override { return 0; }
- Init *convertValue(VarBitInit *VB) override { return 0; }
- Init *convertValue( DefInit *DI) override { return 0; }
+ Init *convertValue( BitInit *BI) override { return nullptr; }
+ Init *convertValue( BitsInit *BI) override { return nullptr; }
+ Init *convertValue( IntInit *II) override { return nullptr; }
+ Init *convertValue(StringInit *SI) override { return nullptr; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
Init *convertValue( UnOpInit *BO) override;
Init *convertValue( BinOpInit *BO) override;
Init *convertValue( TernOpInit *BO) override {return RecTy::convertValue(BO);}
@@ -380,17 +380,17 @@ public:
Record *getRecord() const { return Rec; }
Init *convertValue( UnsetInit *UI) override { return (Init*)UI; }
- Init *convertValue( BitInit *BI) override { return 0; }
- Init *convertValue( BitsInit *BI) override { return 0; }
- Init *convertValue( IntInit *II) override { return 0; }
- Init *convertValue(StringInit *SI) override { return 0; }
- Init *convertValue( ListInit *LI) override { return 0; }
- Init *convertValue(VarBitInit *VB) override { return 0; }
+ Init *convertValue( BitInit *BI) override { return nullptr; }
+ Init *convertValue( BitsInit *BI) override { return nullptr; }
+ Init *convertValue( IntInit *II) override { return nullptr; }
+ Init *convertValue(StringInit *SI) override { return nullptr; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( BinOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( TernOpInit *UI) override {return RecTy::convertValue(UI);}
Init *convertValue( DefInit *DI) override;
- Init *convertValue( DagInit *DI) override { return 0; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
Init *convertValue( TypedInit *VI) override;
Init *convertValue( VarInit *VI) override { return RecTy::convertValue(VI);}
Init *convertValue( FieldInit *FI) override { return RecTy::convertValue(FI);}
@@ -496,7 +496,7 @@ public:
///
virtual Init *
convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
- return 0;
+ return nullptr;
}
/// convertInitListSlice - This method is used to implement the list slice
@@ -506,14 +506,16 @@ public:
///
virtual Init *
convertInitListSlice(const std::vector<unsigned> &Elements) const {
- return 0;
+ return nullptr;
}
/// getFieldType - This method is used to implement the FieldInit class.
/// Implementors of this method should return the type of the named field if
/// they are of record type.
///
- virtual RecTy *getFieldType(const std::string &FieldName) const { return 0; }
+ virtual RecTy *getFieldType(const std::string &FieldName) const {
+ return nullptr;
+ }
/// getFieldInit - This method complements getFieldType to return the
/// initializer for the specified field. If getFieldType returns non-null
@@ -521,7 +523,7 @@ public:
///
virtual Init *getFieldInit(Record &R, const RecordVal *RV,
const std::string &FieldName) const {
- return 0;
+ return nullptr;
}
/// resolveReferences - This method is used by classes that refer to other
@@ -1356,9 +1358,9 @@ public:
bool setValue(Init *V) {
if (V) {
Value = V->convertInitializerTo(Ty);
- return Value == 0;
+ return Value == nullptr;
}
- Value = 0;
+ Value = nullptr;
return false;
}
@@ -1400,13 +1402,13 @@ public:
explicit Record(const std::string &N, ArrayRef<SMLoc> locs,
RecordKeeper &records, bool Anonymous = false) :
ID(LastID++), Name(StringInit::get(N)), Locs(locs.begin(), locs.end()),
- TrackedRecords(records), TheInit(0), IsAnonymous(Anonymous) {
+ TrackedRecords(records), TheInit(nullptr), IsAnonymous(Anonymous) {
init();
}
explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records,
bool Anonymous = false) :
ID(LastID++), Name(N), Locs(locs.begin(), locs.end()),
- TrackedRecords(records), TheInit(0), IsAnonymous(Anonymous) {
+ TrackedRecords(records), TheInit(nullptr), IsAnonymous(Anonymous) {
init();
}
@@ -1461,7 +1463,7 @@ public:
const RecordVal *getValue(const Init *Name) const {
for (unsigned i = 0, e = Values.size(); i != e; ++i)
if (Values[i].getNameInit() == Name) return &Values[i];
- return 0;
+ return nullptr;
}
const RecordVal *getValue(StringRef Name) const {
return getValue(StringInit::get(Name));
@@ -1469,7 +1471,7 @@ public:
RecordVal *getValue(const Init *Name) {
for (unsigned i = 0, e = Values.size(); i != e; ++i)
if (Values[i].getNameInit() == Name) return &Values[i];
- return 0;
+ return nullptr;
}
RecordVal *getValue(StringRef Name) {
return getValue(StringInit::get(Name));
@@ -1531,7 +1533,7 @@ public:
/// resolveReferences - If there are any field references that refer to fields
/// that have been filled in, we can propagate the values now.
///
- void resolveReferences() { resolveReferencesTo(0); }
+ void resolveReferences() { resolveReferencesTo(nullptr); }
/// 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
@@ -1660,11 +1662,11 @@ public:
Record *getClass(const std::string &Name) const {
std::map<std::string, Record*>::const_iterator I = Classes.find(Name);
- return I == Classes.end() ? 0 : I->second;
+ return I == Classes.end() ? nullptr : I->second;
}
Record *getDef(const std::string &Name) const {
std::map<std::string, Record*>::const_iterator I = Defs.find(Name);
- return I == Defs.end() ? 0 : I->second;
+ return I == Defs.end() ? nullptr : I->second;
}
void addClass(Record *R) {
bool Ins = Classes.insert(std::make_pair(R->getName(), R)).second;
Modified: llvm/trunk/lib/TableGen/Record.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/TableGen/Record.cpp?rev=205830&r1=205829&r2=205830&view=diff
==============================================================================
--- llvm/trunk/lib/TableGen/Record.cpp (original)
+++ llvm/trunk/lib/TableGen/Record.cpp Tue Apr 8 23:50:04 2014
@@ -101,13 +101,13 @@ bool RecTy::baseClassOf(const RecTy *RHS
}
Init *BitRecTy::convertValue(BitsInit *BI) {
- if (BI->getNumBits() != 1) return 0; // Only accept if just one bit!
+ if (BI->getNumBits() != 1) return nullptr; // Only accept if just one bit!
return BI->getBit(0);
}
Init *BitRecTy::convertValue(IntInit *II) {
int64_t Val = II->getValue();
- if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit!
+ if (Val != 0 && Val != 1) return nullptr; // Only accept 0 or 1 for a bit!
return BitInit::get(Val != 0);
}
@@ -116,7 +116,7 @@ Init *BitRecTy::convertValue(TypedInit *
RecTy *Ty = VI->getType();
if (isa<BitRecTy>(Ty) || isa<BitsRecTy>(Ty) || isa<IntRecTy>(Ty))
return VI; // Accept variable if it is already of bit type!
- return 0;
+ return nullptr;
}
bool BitRecTy::baseClassOf(const RecTy *RHS) const{
@@ -151,7 +151,7 @@ Init *BitsRecTy::convertValue(UnsetInit
}
Init *BitsRecTy::convertValue(BitInit *UI) {
- if (Size != 1) return 0; // Can only convert single bit.
+ if (Size != 1) return nullptr; // Can only convert single bit.
return BitsInit::get(UI);
}
@@ -170,7 +170,7 @@ Init *BitsRecTy::convertValue(IntInit *I
int64_t Value = II->getValue();
// Make sure this bitfield is large enough to hold the integer value.
if (!canFitInBitfield(Value, Size))
- return 0;
+ return nullptr;
SmallVector<Init *, 16> NewBits(Size);
@@ -184,7 +184,7 @@ Init *BitsRecTy::convertValue(BitsInit *
// If the number of bits is right, return it. Otherwise we need to expand or
// truncate.
if (BI->getNumBits() == Size) return BI;
- return 0;
+ return nullptr;
}
Init *BitsRecTy::convertValue(TypedInit *VI) {
@@ -199,7 +199,7 @@ Init *BitsRecTy::convertValue(TypedInit
return BitsInit::get(NewBits);
}
- return 0;
+ return nullptr;
}
bool BitsRecTy::baseClassOf(const RecTy *RHS) const{
@@ -219,7 +219,7 @@ Init *IntRecTy::convertValue(BitsInit *B
if (BitInit *Bit = dyn_cast<BitInit>(BI->getBit(i))) {
Result |= Bit->getValue() << i;
} else {
- return 0;
+ return nullptr;
}
return IntInit::get(Result);
}
@@ -227,7 +227,7 @@ Init *IntRecTy::convertValue(BitsInit *B
Init *IntRecTy::convertValue(TypedInit *TI) {
if (TI->getType()->typeIsConvertibleTo(this))
return TI; // Accept variable if already of the right type!
- return 0;
+ return nullptr;
}
bool IntRecTy::baseClassOf(const RecTy *RHS) const{
@@ -238,7 +238,7 @@ bool IntRecTy::baseClassOf(const RecTy *
Init *StringRecTy::convertValue(UnOpInit *BO) {
if (BO->getOpcode() == UnOpInit::CAST) {
Init *L = BO->getOperand()->convertInitializerTo(this);
- if (L == 0) return 0;
+ if (!L) return nullptr;
if (L != BO->getOperand())
return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy);
return BO;
@@ -251,7 +251,7 @@ Init *StringRecTy::convertValue(BinOpIni
if (BO->getOpcode() == BinOpInit::STRCONCAT) {
Init *L = BO->getLHS()->convertInitializerTo(this);
Init *R = BO->getRHS()->convertInitializerTo(this);
- if (L == 0 || R == 0) return 0;
+ if (!L || !R) return nullptr;
if (L != BO->getLHS() || R != BO->getRHS())
return BinOpInit::get(BinOpInit::STRCONCAT, L, R, new StringRecTy);
return BO;
@@ -264,7 +264,7 @@ Init *StringRecTy::convertValue(BinOpIni
Init *StringRecTy::convertValue(TypedInit *TI) {
if (isa<StringRecTy>(TI->getType()))
return TI; // Accept variable if already of the right type!
- return 0;
+ return nullptr;
}
std::string ListRecTy::getAsString() const {
@@ -280,10 +280,10 @@ Init *ListRecTy::convertValue(ListInit *
if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty))
Elements.push_back(CI);
else
- return 0;
+ return nullptr;
if (!isa<ListRecTy>(LI->getType()))
- return 0;
+ return nullptr;
return ListInit::get(Elements, this);
}
@@ -293,7 +293,7 @@ Init *ListRecTy::convertValue(TypedInit
if (ListRecTy *LRT = dyn_cast<ListRecTy>(TI->getType()))
if (LRT->getElementType()->typeIsConvertibleTo(getElementType()))
return TI;
- return 0;
+ return nullptr;
}
bool ListRecTy::baseClassOf(const RecTy *RHS) const{
@@ -305,30 +305,30 @@ bool ListRecTy::baseClassOf(const RecTy
Init *DagRecTy::convertValue(TypedInit *TI) {
if (TI->getType()->typeIsConvertibleTo(this))
return TI;
- return 0;
+ return nullptr;
}
Init *DagRecTy::convertValue(UnOpInit *BO) {
if (BO->getOpcode() == UnOpInit::CAST) {
Init *L = BO->getOperand()->convertInitializerTo(this);
- if (L == 0) return 0;
+ if (!L) return nullptr;
if (L != BO->getOperand())
return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy);
return BO;
}
- return 0;
+ return nullptr;
}
Init *DagRecTy::convertValue(BinOpInit *BO) {
if (BO->getOpcode() == BinOpInit::CONCAT) {
Init *L = BO->getLHS()->convertInitializerTo(this);
Init *R = BO->getRHS()->convertInitializerTo(this);
- if (L == 0 || R == 0) return 0;
+ if (!L || !R) return nullptr;
if (L != BO->getLHS() || R != BO->getRHS())
return BinOpInit::get(BinOpInit::CONCAT, L, R, new DagRecTy);
return BO;
}
- return 0;
+ return nullptr;
}
RecordRecTy *RecordRecTy::get(Record *R) {
@@ -342,7 +342,7 @@ std::string RecordRecTy::getAsString() c
Init *RecordRecTy::convertValue(DefInit *DI) {
// Ensure that DI is a subclass of Rec.
if (!DI->getDef()->isSubClassOf(Rec))
- return 0;
+ return nullptr;
return DI;
}
@@ -352,7 +352,7 @@ Init *RecordRecTy::convertValue(TypedIni
if (RRT->getRecord()->isSubClassOf(getRecord()) ||
RRT->getRecord() == getRecord())
return TI;
- return 0;
+ return nullptr;
}
bool RecordRecTy::baseClassOf(const RecTy *RHS) const{
@@ -391,7 +391,7 @@ RecTy *llvm::resolveTypes(RecTy *T1, Rec
++i) {
RecordRecTy *SuperRecTy1 = RecordRecTy::get(*i);
RecTy *NewType1 = resolveTypes(SuperRecTy1, T2);
- if (NewType1 != 0) {
+ if (NewType1) {
if (NewType1 != SuperRecTy1) {
delete SuperRecTy1;
}
@@ -409,7 +409,7 @@ RecTy *llvm::resolveTypes(RecTy *T1, Rec
++i) {
RecordRecTy *SuperRecTy2 = RecordRecTy::get(*i);
RecTy *NewType2 = resolveTypes(T1, SuperRecTy2);
- if (NewType2 != 0) {
+ if (NewType2) {
if (NewType2 != SuperRecTy2) {
delete SuperRecTy2;
}
@@ -417,7 +417,7 @@ RecTy *llvm::resolveTypes(RecTy *T1, Rec
}
}
}
- return 0;
+ return nullptr;
}
@@ -462,7 +462,7 @@ BitsInit *BitsInit::get(ArrayRef<Init *>
FoldingSetNodeID ID;
ProfileBitsInit(ID, Range);
- void *IP = 0;
+ void *IP = nullptr;
if (BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
return I;
@@ -482,7 +482,7 @@ BitsInit::convertInitializerBitRange(con
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= getNumBits())
- return 0;
+ return nullptr;
NewBits[i] = getBit(Bits[i]);
}
return BitsInit::get(NewBits);
@@ -516,8 +516,8 @@ Init *BitsInit::resolveReferences(Record
bool Changed = false;
SmallVector<Init *, 16> NewBits(getNumBits());
- Init *CachedInit = 0;
- Init *CachedBitVar = 0;
+ Init *CachedInit = nullptr;
+ Init *CachedBitVar = nullptr;
bool CachedBitVarChanged = false;
for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
@@ -590,7 +590,7 @@ IntInit::convertInitializerBitRange(cons
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= 64)
- return 0;
+ return nullptr;
NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i]));
}
@@ -629,7 +629,7 @@ ListInit *ListInit::get(ArrayRef<Init *>
FoldingSetNodeID ID;
ProfileListInit(ID, Range, EltTy);
- void *IP = 0;
+ void *IP = nullptr;
if (ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
return I;
@@ -651,7 +651,7 @@ ListInit::convertInitListSlice(const std
std::vector<Init*> Vals;
for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
if (Elements[i] >= getSize())
- return 0;
+ return nullptr;
Vals.push_back(getElement(Elements[i]));
}
return ListInit::get(Vals, getType());
@@ -660,7 +660,7 @@ ListInit::convertInitListSlice(const std
Record *ListInit::getElementAsRecord(unsigned i) const {
assert(i < Values.size() && "List element index out of range!");
DefInit *DI = dyn_cast<DefInit>(Values[i]);
- if (DI == 0)
+ if (!DI)
PrintFatalError("Expected record in list!");
return DI->getDef();
}
@@ -690,14 +690,14 @@ Init *ListInit::resolveReferences(Record
Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV,
unsigned Elt) const {
if (Elt >= getSize())
- return 0; // Out of range reference.
+ return nullptr; // Out of range reference.
Init *E = getElement(Elt);
// If the element is set to some value, or if we are resolving a reference
// to a specific variable and that variable is explicitly unset, then
// replace the VarListElementInit with it.
if (IRV || !isa<UnsetInit>(E))
return E;
- return 0;
+ return nullptr;
}
std::string ListInit::getAsString() const {
@@ -714,7 +714,7 @@ Init *OpInit::resolveListElementReferenc
Init *Resolved = resolveReferences(R, IRV);
OpInit *OResolved = dyn_cast<OpInit>(Resolved);
if (OResolved) {
- Resolved = OResolved->Fold(&R, 0);
+ Resolved = OResolved->Fold(&R, nullptr);
}
if (Resolved != this) {
@@ -728,7 +728,7 @@ Init *OpInit::resolveListElementReferenc
}
}
- return 0;
+ return nullptr;
}
Init *OpInit::getBit(unsigned Bit) const {
@@ -813,7 +813,7 @@ Init *UnOpInit::Fold(Record *CurRec, Mul
if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
if (LHSl->getSize() == 0) {
assert(0 && "Empty list in car");
- return 0;
+ return nullptr;
}
return LHSl->getElement(0);
}
@@ -823,7 +823,7 @@ Init *UnOpInit::Fold(Record *CurRec, Mul
if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
if (LHSl->getSize() == 0) {
assert(0 && "Empty list in cdr");
- return 0;
+ return nullptr;
}
// Note the +1. We can't just pass the result of getValues()
// directly.
@@ -862,8 +862,8 @@ Init *UnOpInit::resolveReferences(Record
Init *lhs = LHS->resolveReferences(R, RV);
if (LHS != lhs)
- return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, 0);
- return Fold(&R, 0);
+ return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, nullptr);
+ return Fold(&R, nullptr);
}
std::string UnOpInit::getAsString() const {
@@ -902,7 +902,7 @@ Init *BinOpInit::Fold(Record *CurRec, Mu
if (LHSs && RHSs) {
DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator());
DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator());
- if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef())
+ if (!LOp || !ROp || LOp->getDef() != ROp->getDef())
PrintFatalError("Concated Dag operators do not match!");
std::vector<Init*> Args;
std::vector<std::string> ArgNames;
@@ -974,8 +974,8 @@ Init *BinOpInit::resolveReferences(Recor
Init *rhs = RHS->resolveReferences(R, RV);
if (LHS != lhs || RHS != rhs)
- return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0);
- return Fold(&R, 0);
+ return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R,nullptr);
+ return Fold(&R, nullptr);
}
std::string BinOpInit::getAsString() const {
@@ -1031,11 +1031,7 @@ static Init *EvaluateOperation(OpInit *R
if (TArg && TArg->getType()->getAsString() == "dag") {
Init *Result = ForeachHelper(LHS, Arg, RHSo, Type,
CurRec, CurMultiClass);
- if (Result != 0) {
- return Result;
- } else {
- return 0;
- }
+ return Result;
}
for (int i = 0; i < RHSo->getNumOperands(); ++i) {
@@ -1044,7 +1040,7 @@ static Init *EvaluateOperation(OpInit *R
if (RHSoo) {
Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
Type, CurRec, CurMultiClass);
- if (Result != 0) {
+ if (Result) {
NewOperands.push_back(Result);
} else {
NewOperands.push_back(Arg);
@@ -1059,10 +1055,7 @@ static Init *EvaluateOperation(OpInit *R
// Now run the operator and use its result as the new leaf
const OpInit *NewOp = RHSo->clone(NewOperands);
Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
- if (NewVal != NewOp)
- return NewVal;
-
- return 0;
+ return (NewVal != NewOp) ? NewVal : nullptr;
}
static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
@@ -1086,7 +1079,7 @@ static Init *ForeachHelper(Init *LHS, In
Init *Val = MHSd->getOperator();
Init *Result = EvaluateOperation(RHSo, LHS, Val,
Type, CurRec, CurMultiClass);
- if (Result != 0) {
+ if (Result) {
Val = Result;
}
@@ -1100,7 +1093,7 @@ static Init *ForeachHelper(Init *LHS, In
// Process args
Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
CurRec, CurMultiClass);
- if (Result != 0) {
+ if (Result) {
Arg = Result;
}
@@ -1138,7 +1131,7 @@ static Init *ForeachHelper(Init *LHS, In
return ListInit::get(NewList, MHSl->getType());
}
}
- return 0;
+ return nullptr;
}
Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
@@ -1195,7 +1188,7 @@ Init *TernOpInit::Fold(Record *CurRec, M
case FOREACH: {
Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
CurRec, CurMultiClass);
- if (Result != 0) {
+ if (Result) {
return Result;
}
break;
@@ -1227,16 +1220,16 @@ Init *TernOpInit::resolveReferences(Reco
IntInit *Value = dyn_cast<IntInit>(lhs);
if (Init *I = lhs->convertInitializerTo(IntRecTy::get()))
Value = dyn_cast<IntInit>(I);
- if (Value != 0) {
+ if (Value) {
// Short-circuit
if (Value->getValue()) {
Init *mhs = MHS->resolveReferences(R, RV);
return (TernOpInit::get(getOpcode(), lhs, mhs,
- RHS, getType()))->Fold(&R, 0);
+ RHS, getType()))->Fold(&R, nullptr);
} else {
Init *rhs = RHS->resolveReferences(R, RV);
return (TernOpInit::get(getOpcode(), lhs, MHS,
- rhs, getType()))->Fold(&R, 0);
+ rhs, getType()))->Fold(&R, nullptr);
}
}
}
@@ -1246,8 +1239,8 @@ Init *TernOpInit::resolveReferences(Reco
if (LHS != lhs || MHS != mhs || RHS != rhs)
return (TernOpInit::get(getOpcode(), lhs, mhs, rhs,
- getType()))->Fold(&R, 0);
- return Fold(&R, 0);
+ getType()))->Fold(&R, nullptr);
+ return Fold(&R, nullptr);
}
std::string TernOpInit::getAsString() const {
@@ -1265,19 +1258,19 @@ RecTy *TypedInit::getFieldType(const std
if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType()))
if (RecordVal *Field = RecordType->getRecord()->getValue(FieldName))
return Field->getType();
- return 0;
+ return nullptr;
}
Init *
TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
BitsRecTy *T = dyn_cast<BitsRecTy>(getType());
- if (T == 0) return 0; // Cannot subscript a non-bits variable.
+ if (!T) return nullptr; // Cannot subscript a non-bits variable.
unsigned NumBits = T->getNumBits();
SmallVector<Init *, 16> NewBits(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= NumBits)
- return 0;
+ return nullptr;
NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), Bits[i]);
}
@@ -1287,7 +1280,7 @@ TypedInit::convertInitializerBitRange(co
Init *
TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
ListRecTy *T = dyn_cast<ListRecTy>(getType());
- if (T == 0) return 0; // Cannot subscript a non-list variable.
+ if (!T) return nullptr; // Cannot subscript a non-list variable.
if (Elements.size() == 1)
return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]);
@@ -1332,8 +1325,8 @@ Init *VarInit::getBit(unsigned Bit) cons
Init *VarInit::resolveListElementReference(Record &R,
const RecordVal *IRV,
unsigned Elt) const {
- if (R.isTemplateArg(getNameInit())) return 0;
- if (IRV && IRV->getNameInit() != getNameInit()) return 0;
+ if (R.isTemplateArg(getNameInit())) return nullptr;
+ if (IRV && IRV->getNameInit() != getNameInit()) return nullptr;
RecordVal *RV = R.getValue(getNameInit());
assert(RV && "Reference to a non-existent variable?");
@@ -1345,14 +1338,14 @@ Init *VarInit::resolveListElementReferen
}
if (Elt >= LI->getSize())
- return 0; // Out of range reference.
+ return nullptr; // Out of range reference.
Init *E = LI->getElement(Elt);
// If the element is set to some value, or if we are resolving a reference
// to a specific variable and that variable is explicitly unset, then
// replace the VarListElementInit with it.
if (IRV || !isa<UnsetInit>(E))
return E;
- return 0;
+ return nullptr;
}
@@ -1360,7 +1353,7 @@ RecTy *VarInit::getFieldType(const std::
if (RecordRecTy *RTy = dyn_cast<RecordRecTy>(getType()))
if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName))
return RV->getType();
- return 0;
+ return nullptr;
}
Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
@@ -1368,15 +1361,15 @@ Init *VarInit::getFieldInit(Record &R, c
if (isa<RecordRecTy>(getType()))
if (const RecordVal *Val = R.getValue(VarName)) {
if (RV != Val && (RV || isa<UnsetInit>(Val->getValue())))
- return 0;
+ return nullptr;
Init *TheInit = Val->getValue();
assert(TheInit != this && "Infinite loop detected!");
if (Init *I = TheInit->getFieldInit(R, RV, FieldName))
return I;
else
- return 0;
+ return nullptr;
}
- return 0;
+ return nullptr;
}
/// resolveReferences - This method is used by classes that refer to other
@@ -1386,7 +1379,7 @@ Init *VarInit::getFieldInit(Record &R, c
///
Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) const {
if (RecordVal *Val = R.getValue(VarName))
- if (RV == Val || (RV == 0 && !isa<UnsetInit>(Val->getValue())))
+ if (RV == Val || (!RV && !isa<UnsetInit>(Val->getValue())))
return Val->getValue();
return const_cast<VarInit *>(this);
}
@@ -1462,7 +1455,7 @@ Init *VarListElementInit:: resolveListEl
return Result;
}
- return 0;
+ return nullptr;
}
DefInit *DefInit::get(Record *R) {
@@ -1472,7 +1465,7 @@ DefInit *DefInit::get(Record *R) {
RecTy *DefInit::getFieldType(const std::string &FieldName) const {
if (const RecordVal *RV = Def->getValue(FieldName))
return RV->getType();
- return 0;
+ return nullptr;
}
Init *DefInit::getFieldInit(Record &R, const RecordVal *RV,
@@ -1507,7 +1500,7 @@ Init *FieldInit::resolveListElementRefer
unsigned Elt) const {
if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName))
if (ListInit *LI = dyn_cast<ListInit>(ListVal)) {
- if (Elt >= LI->getSize()) return 0;
+ if (Elt >= LI->getSize()) return nullptr;
Init *E = LI->getElement(Elt);
// If the element is set to some value, or if we are resolving a
@@ -1516,7 +1509,7 @@ Init *FieldInit::resolveListElementRefer
if (RV || !isa<UnsetInit>(E))
return E;
}
- return 0;
+ return nullptr;
}
Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const {
@@ -1560,7 +1553,7 @@ DagInit::get(Init *V, const std::string
FoldingSetNodeID ID;
ProfileDagInit(ID, V, VN, ArgRange, NameRange);
- void *IP = 0;
+ void *IP = nullptr;
if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
return I;
@@ -1784,7 +1777,7 @@ raw_ostream &llvm::operator<<(raw_ostrea
///
Init *Record::getValueInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
- if (R == 0 || R->getValue() == 0)
+ if (!R || !R->getValue())
PrintFatalError(getLoc(), "Record `" + getName() +
"' does not have a field named `" + FieldName + "'!\n");
return R->getValue();
@@ -1797,7 +1790,7 @@ Init *Record::getValueInit(StringRef Fie
///
std::string Record::getValueAsString(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
- if (R == 0 || R->getValue() == 0)
+ if (!R || !R->getValue())
PrintFatalError(getLoc(), "Record `" + getName() +
"' does not have a field named `" + FieldName + "'!\n");
@@ -1813,7 +1806,7 @@ std::string Record::getValueAsString(Str
///
BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
- if (R == 0 || R->getValue() == 0)
+ if (!R || !R->getValue())
PrintFatalError(getLoc(), "Record `" + getName() +
"' does not have a field named `" + FieldName + "'!\n");
@@ -1829,7 +1822,7 @@ BitsInit *Record::getValueAsBitsInit(Str
///
ListInit *Record::getValueAsListInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
- if (R == 0 || R->getValue() == 0)
+ if (!R || !R->getValue())
PrintFatalError(getLoc(), "Record `" + getName() +
"' does not have a field named `" + FieldName + "'!\n");
@@ -1864,7 +1857,7 @@ Record::getValueAsListOfDefs(StringRef F
///
int64_t Record::getValueAsInt(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
- if (R == 0 || R->getValue() == 0)
+ if (!R || !R->getValue())
PrintFatalError(getLoc(), "Record `" + getName() +
"' does not have a field named `" + FieldName + "'!\n");
@@ -1918,7 +1911,7 @@ Record::getValueAsListOfStrings(StringRe
///
Record *Record::getValueAsDef(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
- if (R == 0 || R->getValue() == 0)
+ if (!R || !R->getValue())
PrintFatalError(getLoc(), "Record `" + getName() +
"' does not have a field named `" + FieldName + "'!\n");
@@ -1934,7 +1927,7 @@ Record *Record::getValueAsDef(StringRef
///
bool Record::getValueAsBit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
- if (R == 0 || R->getValue() == 0)
+ if (!R || !R->getValue())
PrintFatalError(getLoc(), "Record `" + getName() +
"' does not have a field named `" + FieldName + "'!\n");
@@ -1946,7 +1939,7 @@ bool Record::getValueAsBit(StringRef Fie
bool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const {
const RecordVal *R = getValue(FieldName);
- if (R == 0 || R->getValue() == 0)
+ if (!R || !R->getValue())
PrintFatalError(getLoc(), "Record `" + getName() +
"' does not have a field named `" + FieldName.str() + "'!\n");
@@ -1967,7 +1960,7 @@ bool Record::getValueAsBitOrUnset(String
///
DagInit *Record::getValueAsDag(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
- if (R == 0 || R->getValue() == 0)
+ if (!R || !R->getValue())
PrintFatalError(getLoc(), "Record `" + getName() +
"' does not have a field named `" + FieldName + "'!\n");
Modified: llvm/trunk/lib/TableGen/TGLexer.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/TableGen/TGLexer.cpp?rev=205830&r1=205829&r2=205830&view=diff
==============================================================================
--- llvm/trunk/lib/TableGen/TGLexer.cpp (original)
+++ llvm/trunk/lib/TableGen/TGLexer.cpp Tue Apr 8 23:50:04 2014
@@ -30,7 +30,7 @@ TGLexer::TGLexer(SourceMgr &SM) : SrcMgr
CurBuffer = 0;
CurBuf = SrcMgr.getMemoryBuffer(CurBuffer);
CurPtr = CurBuf->getBufferStart();
- TokStart = 0;
+ TokStart = nullptr;
}
SMLoc TGLexer::getLoc() const {
@@ -389,12 +389,12 @@ tgtok::TokKind TGLexer::LexNumber() {
return ReturnError(TokStart, "Invalid hexadecimal number");
errno = 0;
- CurIntVal = strtoll(NumStart, 0, 16);
+ CurIntVal = strtoll(NumStart, nullptr, 16);
if (errno == EINVAL)
return ReturnError(TokStart, "Invalid hexadecimal number");
if (errno == ERANGE) {
errno = 0;
- CurIntVal = (int64_t)strtoull(NumStart, 0, 16);
+ CurIntVal = (int64_t)strtoull(NumStart, nullptr, 16);
if (errno == EINVAL)
return ReturnError(TokStart, "Invalid hexadecimal number");
if (errno == ERANGE)
@@ -410,7 +410,7 @@ tgtok::TokKind TGLexer::LexNumber() {
// Requires at least one binary digit.
if (CurPtr == NumStart)
return ReturnError(CurPtr-2, "Invalid binary number");
- CurIntVal = strtoll(NumStart, 0, 2);
+ CurIntVal = strtoll(NumStart, nullptr, 2);
return tgtok::IntVal;
}
}
@@ -425,7 +425,7 @@ tgtok::TokKind TGLexer::LexNumber() {
while (isdigit(CurPtr[0]))
++CurPtr;
- CurIntVal = strtoll(TokStart, 0, 10);
+ CurIntVal = strtoll(TokStart, nullptr, 10);
return tgtok::IntVal;
}
Modified: llvm/trunk/lib/TableGen/TGParser.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/TableGen/TGParser.cpp?rev=205830&r1=205829&r2=205830&view=diff
==============================================================================
--- llvm/trunk/lib/TableGen/TGParser.cpp (original)
+++ llvm/trunk/lib/TableGen/TGParser.cpp Tue Apr 8 23:50:04 2014
@@ -29,18 +29,18 @@ struct SubClassReference {
SMRange RefRange;
Record *Rec;
std::vector<Init*> TemplateArgs;
- SubClassReference() : Rec(0) {}
+ SubClassReference() : Rec(nullptr) {}
- bool isInvalid() const { return Rec == 0; }
+ bool isInvalid() const { return Rec == nullptr; }
};
struct SubMultiClassReference {
SMRange RefRange;
MultiClass *MC;
std::vector<Init*> TemplateArgs;
- SubMultiClassReference() : MC(0) {}
+ SubMultiClassReference() : MC(nullptr) {}
- bool isInvalid() const { return MC == 0; }
+ bool isInvalid() const { return MC == nullptr; }
void dump() const;
};
@@ -61,7 +61,7 @@ void SubMultiClassReference::dump() cons
} // end namespace llvm
bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
- if (CurRec == 0)
+ if (!CurRec)
CurRec = &CurMultiClass->Rec;
if (RecordVal *ERV = CurRec->getValue(RV.getNameInit())) {
@@ -83,10 +83,10 @@ bool TGParser::SetValue(Record *CurRec,
const std::vector<unsigned> &BitList, Init *V) {
if (!V) return false;
- if (CurRec == 0) CurRec = &CurMultiClass->Rec;
+ if (!CurRec) CurRec = &CurMultiClass->Rec;
RecordVal *RV = CurRec->getValue(ValName);
- if (RV == 0)
+ if (!RV)
return Error(Loc, "Value '" + ValName->getAsUnquotedString()
+ "' unknown!");
@@ -103,13 +103,13 @@ bool TGParser::SetValue(Record *CurRec,
//
if (!BitList.empty()) {
BitsInit *CurVal = dyn_cast<BitsInit>(RV->getValue());
- if (CurVal == 0)
+ if (!CurVal)
return Error(Loc, "Value '" + ValName->getAsUnquotedString()
+ "' is not a bits type");
// Convert the incoming value to a bits type of the appropriate size...
Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size()));
- if (BI == 0) {
+ if (!BI) {
return Error(Loc, "Initializer is not compatible with bit range");
}
@@ -129,7 +129,7 @@ bool TGParser::SetValue(Record *CurRec,
}
for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
- if (NewBits[i] == 0)
+ if (!NewBits[i])
NewBits[i] = CurVal->getBit(i);
V = BitsInit::get(NewBits);
@@ -314,14 +314,14 @@ bool TGParser::ProcessForeachDefs(Record
assert(IterVals.size() < Loops.size());
ForeachLoop &CurLoop = Loops[IterVals.size()];
ListInit *List = dyn_cast<ListInit>(CurLoop.ListValue);
- if (List == 0) {
+ if (!List) {
Error(Loc, "Loop list is not a list");
return true;
}
// Process each value.
for (int64_t i = 0; i < List->getSize(); ++i) {
- Init *ItemVal = List->resolveListElementReference(*CurRec, 0, i);
+ Init *ItemVal = List->resolveListElementReference(*CurRec, nullptr, i);
IterVals.push_back(IterRecord(CurLoop.IterVar, ItemVal));
if (ProcessForeachDefs(CurRec, Loc, IterVals))
return true;
@@ -339,7 +339,7 @@ bool TGParser::ProcessForeachDefs(Record
for (unsigned i = 0, e = IterVals.size(); i != e; ++i) {
VarInit *IterVar = IterVals[i].IterVar;
TypedInit *IVal = dyn_cast<TypedInit>(IterVals[i].IterValue);
- if (IVal == 0) {
+ if (!IVal) {
Error(Loc, "foreach iterator value is untyped");
return true;
}
@@ -400,21 +400,21 @@ Init *TGParser::ParseObjectName(MultiCla
// These are all of the tokens that can begin an object body.
// Some of these can also begin values but we disallow those cases
// because they are unlikely to be useful.
- return 0;
+ return nullptr;
default:
break;
}
- Record *CurRec = 0;
+ Record *CurRec = nullptr;
if (CurMultiClass)
CurRec = &CurMultiClass->Rec;
- RecTy *Type = 0;
+ RecTy *Type = nullptr;
if (CurRec) {
const TypedInit *CurRecName = dyn_cast<TypedInit>(CurRec->getNameInit());
if (!CurRecName) {
TokError("Record name is not typed!");
- return 0;
+ return nullptr;
}
Type = CurRecName->getType();
}
@@ -430,11 +430,11 @@ Init *TGParser::ParseObjectName(MultiCla
Record *TGParser::ParseClassID() {
if (Lex.getCode() != tgtok::Id) {
TokError("expected name for ClassID");
- return 0;
+ return nullptr;
}
Record *Result = Records.getClass(Lex.getCurStrVal());
- if (Result == 0)
+ if (!Result)
TokError("Couldn't find class '" + Lex.getCurStrVal() + "'");
Lex.Lex();
@@ -449,11 +449,11 @@ Record *TGParser::ParseClassID() {
MultiClass *TGParser::ParseMultiClassID() {
if (Lex.getCode() != tgtok::Id) {
TokError("expected name for MultiClassID");
- return 0;
+ return nullptr;
}
MultiClass *Result = MultiClasses[Lex.getCurStrVal()];
- if (Result == 0)
+ if (!Result)
TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'");
Lex.Lex();
@@ -477,7 +477,7 @@ ParseSubClassReference(Record *CurRec, b
} else {
Result.Rec = ParseClassID();
}
- if (Result.Rec == 0) return Result;
+ if (!Result.Rec) return Result;
// If there is no template arg list, we're done.
if (Lex.getCode() != tgtok::less) {
@@ -488,19 +488,19 @@ ParseSubClassReference(Record *CurRec, b
if (Lex.getCode() == tgtok::greater) {
TokError("subclass reference requires a non-empty list of template values");
- Result.Rec = 0;
+ Result.Rec = nullptr;
return Result;
}
Result.TemplateArgs = ParseValueList(CurRec, Result.Rec);
if (Result.TemplateArgs.empty()) {
- Result.Rec = 0; // Error parsing value list.
+ Result.Rec = nullptr; // Error parsing value list.
return Result;
}
if (Lex.getCode() != tgtok::greater) {
TokError("expected '>' in template value list");
- Result.Rec = 0;
+ Result.Rec = nullptr;
return Result;
}
Lex.Lex();
@@ -522,7 +522,7 @@ ParseSubMultiClassReference(MultiClass *
Result.RefRange.Start = Lex.getLoc();
Result.MC = ParseMultiClassID();
- if (Result.MC == 0) return Result;
+ if (!Result.MC) return Result;
// If there is no template arg list, we're done.
if (Lex.getCode() != tgtok::less) {
@@ -533,19 +533,19 @@ ParseSubMultiClassReference(MultiClass *
if (Lex.getCode() == tgtok::greater) {
TokError("subclass reference requires a non-empty list of template values");
- Result.MC = 0;
+ Result.MC = nullptr;
return Result;
}
Result.TemplateArgs = ParseValueList(&CurMC->Rec, &Result.MC->Rec);
if (Result.TemplateArgs.empty()) {
- Result.MC = 0; // Error parsing value list.
+ Result.MC = nullptr; // Error parsing value list.
return Result;
}
if (Lex.getCode() != tgtok::greater) {
TokError("expected '>' in template value list");
- Result.MC = 0;
+ Result.MC = nullptr;
return Result;
}
Lex.Lex();
@@ -677,7 +677,7 @@ bool TGParser::ParseOptionalBitList(std:
///
RecTy *TGParser::ParseType() {
switch (Lex.getCode()) {
- default: TokError("Unknown token when expecting a type"); return 0;
+ default: TokError("Unknown token when expecting a type"); return nullptr;
case tgtok::String: Lex.Lex(); return StringRecTy::get();
case tgtok::Code: Lex.Lex(); return StringRecTy::get();
case tgtok::Bit: Lex.Lex(); return BitRecTy::get();
@@ -685,20 +685,20 @@ RecTy *TGParser::ParseType() {
case tgtok::Dag: Lex.Lex(); return DagRecTy::get();
case tgtok::Id:
if (Record *R = ParseClassID()) return RecordRecTy::get(R);
- return 0;
+ return nullptr;
case tgtok::Bits: {
if (Lex.Lex() != tgtok::less) { // Eat 'bits'
TokError("expected '<' after bits type");
- return 0;
+ return nullptr;
}
if (Lex.Lex() != tgtok::IntVal) { // Eat '<'
TokError("expected integer in bits<n> type");
- return 0;
+ return nullptr;
}
uint64_t Val = Lex.getCurIntVal();
if (Lex.Lex() != tgtok::greater) { // Eat count.
TokError("expected '>' at end of bits<n> type");
- return 0;
+ return nullptr;
}
Lex.Lex(); // Eat '>'
return BitsRecTy::get(Val);
@@ -706,15 +706,15 @@ RecTy *TGParser::ParseType() {
case tgtok::List: {
if (Lex.Lex() != tgtok::less) { // Eat 'bits'
TokError("expected '<' after list type");
- return 0;
+ return nullptr;
}
Lex.Lex(); // Eat '<'
RecTy *SubType = ParseType();
- if (SubType == 0) return 0;
+ if (!SubType) return nullptr;
if (Lex.getCode() != tgtok::greater) {
TokError("expected '>' at end of list<ty> type");
- return 0;
+ return nullptr;
}
Lex.Lex(); // Eat '>'
return ListRecTy::get(SubType);
@@ -772,7 +772,7 @@ Init *TGParser::ParseIDValue(Record *Cur
if (Mode == ParseValueMode) {
Error(NameLoc, "Variable not defined: '" + Name + "'");
- return 0;
+ return nullptr;
}
return StringInit::get(Name);
@@ -786,13 +786,13 @@ Init *TGParser::ParseOperation(Record *C
switch (Lex.getCode()) {
default:
TokError("unknown operation");
- return 0;
+ return nullptr;
case tgtok::XHead:
case tgtok::XTail:
case tgtok::XEmpty:
case tgtok::XCast: { // Value ::= !unop '(' Value ')'
UnOpInit::UnaryOp Code;
- RecTy *Type = 0;
+ RecTy *Type = nullptr;
switch (Lex.getCode()) {
default: llvm_unreachable("Unhandled code!");
@@ -802,9 +802,9 @@ Init *TGParser::ParseOperation(Record *C
Type = ParseOperatorType();
- if (Type == 0) {
+ if (!Type) {
TokError("did not get type for unary operator");
- return 0;
+ return nullptr;
}
break;
@@ -824,12 +824,12 @@ Init *TGParser::ParseOperation(Record *C
}
if (Lex.getCode() != tgtok::l_paren) {
TokError("expected '(' after unary operator");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the '('
Init *LHS = ParseValue(CurRec);
- if (LHS == 0) return 0;
+ if (!LHS) return nullptr;
if (Code == UnOpInit::HEAD
|| Code == UnOpInit::TAIL
@@ -837,36 +837,36 @@ Init *TGParser::ParseOperation(Record *C
ListInit *LHSl = dyn_cast<ListInit>(LHS);
StringInit *LHSs = dyn_cast<StringInit>(LHS);
TypedInit *LHSt = dyn_cast<TypedInit>(LHS);
- if (LHSl == 0 && LHSs == 0 && LHSt == 0) {
+ if (!LHSl && !LHSs && !LHSt) {
TokError("expected list or string type argument in unary operator");
- return 0;
+ return nullptr;
}
if (LHSt) {
ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType());
StringRecTy *SType = dyn_cast<StringRecTy>(LHSt->getType());
- if (LType == 0 && SType == 0) {
+ if (!LType && !SType) {
TokError("expected list or string type argumnet in unary operator");
- return 0;
+ return nullptr;
}
}
if (Code == UnOpInit::HEAD
|| Code == UnOpInit::TAIL) {
- if (LHSl == 0 && LHSt == 0) {
+ if (!LHSl && !LHSt) {
TokError("expected list type argumnet in unary operator");
- return 0;
+ return nullptr;
}
if (LHSl && LHSl->getSize() == 0) {
TokError("empty list argument in unary operator");
- return 0;
+ return nullptr;
}
if (LHSl) {
Init *Item = LHSl->getElement(0);
TypedInit *Itemt = dyn_cast<TypedInit>(Item);
- if (Itemt == 0) {
+ if (!Itemt) {
TokError("untyped list element in unary operator");
- return 0;
+ return nullptr;
}
if (Code == UnOpInit::HEAD) {
Type = Itemt->getType();
@@ -876,9 +876,9 @@ Init *TGParser::ParseOperation(Record *C
} else {
assert(LHSt && "expected list type argument in unary operator");
ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType());
- if (LType == 0) {
+ if (!LType) {
TokError("expected list type argumnet in unary operator");
- return 0;
+ return nullptr;
}
if (Code == UnOpInit::HEAD) {
Type = LType->getElementType();
@@ -891,7 +891,7 @@ Init *TGParser::ParseOperation(Record *C
if (Lex.getCode() != tgtok::r_paren) {
TokError("expected ')' in unary operator");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the ')'
return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
@@ -909,7 +909,7 @@ Init *TGParser::ParseOperation(Record *C
Lex.Lex(); // eat the operation
BinOpInit::BinaryOp Code;
- RecTy *Type = 0;
+ RecTy *Type = nullptr;
switch (OpTok) {
default: llvm_unreachable("Unhandled code!");
@@ -927,25 +927,25 @@ Init *TGParser::ParseOperation(Record *C
if (Lex.getCode() != tgtok::l_paren) {
TokError("expected '(' after binary operator");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the '('
SmallVector<Init*, 2> InitList;
InitList.push_back(ParseValue(CurRec));
- if (InitList.back() == 0) return 0;
+ if (!InitList.back()) return nullptr;
while (Lex.getCode() == tgtok::comma) {
Lex.Lex(); // eat the ','
InitList.push_back(ParseValue(CurRec));
- if (InitList.back() == 0) return 0;
+ if (!InitList.back()) return nullptr;
}
if (Lex.getCode() != tgtok::r_paren) {
TokError("expected ')' in operator");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the ')'
@@ -965,14 +965,14 @@ Init *TGParser::ParseOperation(Record *C
->Fold(CurRec, CurMultiClass);
Error(OpLoc, "expected two operands to operator");
- return 0;
+ return nullptr;
}
case tgtok::XIf:
case tgtok::XForEach:
case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')'
TernOpInit::TernaryOp Code;
- RecTy *Type = 0;
+ RecTy *Type = nullptr;
tgtok::TokKind LexCode = Lex.getCode();
Lex.Lex(); // eat the operation
@@ -990,42 +990,42 @@ Init *TGParser::ParseOperation(Record *C
}
if (Lex.getCode() != tgtok::l_paren) {
TokError("expected '(' after ternary operator");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the '('
Init *LHS = ParseValue(CurRec);
- if (LHS == 0) return 0;
+ if (!LHS) return nullptr;
if (Lex.getCode() != tgtok::comma) {
TokError("expected ',' in ternary operator");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the ','
Init *MHS = ParseValue(CurRec);
- if (MHS == 0) return 0;
+ if (!MHS) return nullptr;
if (Lex.getCode() != tgtok::comma) {
TokError("expected ',' in ternary operator");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the ','
Init *RHS = ParseValue(CurRec);
- if (RHS == 0) return 0;
+ if (!RHS) return nullptr;
if (Lex.getCode() != tgtok::r_paren) {
TokError("expected ')' in binary operator");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the ')'
switch (LexCode) {
default: llvm_unreachable("Unhandled code!");
case tgtok::XIf: {
- RecTy *MHSTy = 0;
- RecTy *RHSTy = 0;
+ RecTy *MHSTy = nullptr;
+ RecTy *RHSTy = nullptr;
if (TypedInit *MHSt = dyn_cast<TypedInit>(MHS))
MHSTy = MHSt->getType();
@@ -1049,7 +1049,7 @@ Init *TGParser::ParseOperation(Record *C
if (!MHSTy || !RHSTy) {
TokError("could not get type for !if");
- return 0;
+ return nullptr;
}
if (MHSTy->typeIsConvertibleTo(RHSTy)) {
@@ -1058,24 +1058,24 @@ Init *TGParser::ParseOperation(Record *C
Type = MHSTy;
} else {
TokError("inconsistent types for !if");
- return 0;
+ return nullptr;
}
break;
}
case tgtok::XForEach: {
TypedInit *MHSt = dyn_cast<TypedInit>(MHS);
- if (MHSt == 0) {
+ if (!MHSt) {
TokError("could not get type for !foreach");
- return 0;
+ return nullptr;
}
Type = MHSt->getType();
break;
}
case tgtok::XSubst: {
TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
- if (RHSt == 0) {
+ if (!RHSt) {
TokError("could not get type for !subst");
- return 0;
+ return nullptr;
}
Type = RHSt->getType();
break;
@@ -1093,24 +1093,24 @@ Init *TGParser::ParseOperation(Record *C
/// OperatorType ::= '<' Type '>'
///
RecTy *TGParser::ParseOperatorType() {
- RecTy *Type = 0;
+ RecTy *Type = nullptr;
if (Lex.getCode() != tgtok::less) {
TokError("expected type name for operator");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the <
Type = ParseType();
- if (Type == 0) {
+ if (!Type) {
TokError("expected type name for operator");
- return 0;
+ return nullptr;
}
if (Lex.getCode() != tgtok::greater) {
TokError("expected type name for operator");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the >
@@ -1138,7 +1138,7 @@ RecTy *TGParser::ParseOperatorType() {
///
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
IDParseMode Mode) {
- Init *R = 0;
+ Init *R = nullptr;
switch (Lex.getCode()) {
default: TokError("Unknown token when parsing a value"); break;
case tgtok::paste:
@@ -1177,7 +1177,7 @@ Init *TGParser::ParseSimpleValue(Record
// Value ::= ID '<' ValueListNE '>'
if (Lex.Lex() == tgtok::greater) {
TokError("expected non-empty value list");
- return 0;
+ return nullptr;
}
// This is a CLASS<initvalslist> expression. This is supposed to synthesize
@@ -1186,15 +1186,15 @@ Init *TGParser::ParseSimpleValue(Record
Record *Class = Records.getClass(Name);
if (!Class) {
Error(NameLoc, "Expected a class name, got '" + Name + "'");
- return 0;
+ return nullptr;
}
std::vector<Init*> ValueList = ParseValueList(CurRec, Class);
- if (ValueList.empty()) return 0;
+ if (ValueList.empty()) return nullptr;
if (Lex.getCode() != tgtok::greater) {
TokError("expected '>' at end of value list");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the '>'
SMLoc EndLoc = Lex.getLoc();
@@ -1208,7 +1208,7 @@ Init *TGParser::ParseSimpleValue(Record
SCRef.TemplateArgs = ValueList;
// Add info about the subclass to NewRec.
if (AddSubClass(NewRec, SCRef))
- return 0;
+ return nullptr;
if (!CurMultiClass) {
NewRec->resolveReferences();
Records.addDef(NewRec);
@@ -1250,11 +1250,11 @@ Init *TGParser::ParseSimpleValue(Record
if (Lex.getCode() != tgtok::r_brace) {
Vals = ParseValueList(CurRec);
- if (Vals.empty()) return 0;
+ if (Vals.empty()) return nullptr;
}
if (Lex.getCode() != tgtok::r_brace) {
TokError("expected '}' at end of bit list value");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the '}'
@@ -1262,10 +1262,10 @@ Init *TGParser::ParseSimpleValue(Record
for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
- if (Bit == 0) {
+ if (!Bit) {
Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+
") is not convertable to a bit");
- return 0;
+ return nullptr;
}
NewBits[Vals.size()-i-1] = Bit;
}
@@ -1275,87 +1275,87 @@ Init *TGParser::ParseSimpleValue(Record
Lex.Lex(); // eat the '['
std::vector<Init*> Vals;
- RecTy *DeducedEltTy = 0;
- ListRecTy *GivenListTy = 0;
+ RecTy *DeducedEltTy = nullptr;
+ ListRecTy *GivenListTy = nullptr;
- if (ItemType != 0) {
+ if (ItemType) {
ListRecTy *ListType = dyn_cast<ListRecTy>(ItemType);
- if (ListType == 0) {
+ if (!ListType) {
std::string s;
raw_string_ostream ss(s);
ss << "Type mismatch for list, expected list type, got "
<< ItemType->getAsString();
TokError(ss.str());
- return 0;
+ return nullptr;
}
GivenListTy = ListType;
}
if (Lex.getCode() != tgtok::r_square) {
- Vals = ParseValueList(CurRec, 0,
- GivenListTy ? GivenListTy->getElementType() : 0);
- if (Vals.empty()) return 0;
+ Vals = ParseValueList(CurRec, nullptr,
+ GivenListTy ? GivenListTy->getElementType() : nullptr);
+ if (Vals.empty()) return nullptr;
}
if (Lex.getCode() != tgtok::r_square) {
TokError("expected ']' at end of list value");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the ']'
- RecTy *GivenEltTy = 0;
+ RecTy *GivenEltTy = nullptr;
if (Lex.getCode() == tgtok::less) {
// Optional list element type
Lex.Lex(); // eat the '<'
GivenEltTy = ParseType();
- if (GivenEltTy == 0) {
+ if (!GivenEltTy) {
// Couldn't parse element type
- return 0;
+ return nullptr;
}
if (Lex.getCode() != tgtok::greater) {
TokError("expected '>' at end of list element type");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the '>'
}
// Check elements
- RecTy *EltTy = 0;
+ RecTy *EltTy = nullptr;
for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end();
i != ie;
++i) {
TypedInit *TArg = dyn_cast<TypedInit>(*i);
- if (TArg == 0) {
+ if (!TArg) {
TokError("Untyped list element");
- return 0;
+ return nullptr;
}
- if (EltTy != 0) {
+ if (EltTy) {
EltTy = resolveTypes(EltTy, TArg->getType());
- if (EltTy == 0) {
+ if (!EltTy) {
TokError("Incompatible types in list elements");
- return 0;
+ return nullptr;
}
} else {
EltTy = TArg->getType();
}
}
- if (GivenEltTy != 0) {
- if (EltTy != 0) {
+ if (GivenEltTy) {
+ if (EltTy) {
// Verify consistency
if (!EltTy->typeIsConvertibleTo(GivenEltTy)) {
TokError("Incompatible types in list elements");
- return 0;
+ return nullptr;
}
}
EltTy = GivenEltTy;
}
- if (EltTy == 0) {
- if (ItemType == 0) {
+ if (!EltTy) {
+ if (!ItemType) {
TokError("No type for list");
- return 0;
+ return nullptr;
}
DeducedEltTy = GivenListTy->getElementType();
} else {
@@ -1363,7 +1363,7 @@ Init *TGParser::ParseSimpleValue(Record
if (GivenListTy) {
if (!EltTy->typeIsConvertibleTo(GivenListTy->getElementType())) {
TokError("Element type mismatch for list");
- return 0;
+ return nullptr;
}
}
DeducedEltTy = EltTy;
@@ -1375,18 +1375,18 @@ Init *TGParser::ParseSimpleValue(Record
Lex.Lex(); // eat the '('
if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast) {
TokError("expected identifier in dag init");
- return 0;
+ return nullptr;
}
Init *Operator = ParseValue(CurRec);
- if (Operator == 0) return 0;
+ if (!Operator) return nullptr;
// If the operator name is present, parse it.
std::string OperatorName;
if (Lex.getCode() == tgtok::colon) {
if (Lex.Lex() != tgtok::VarName) { // eat the ':'
TokError("expected variable name in dag operator");
- return 0;
+ return nullptr;
}
OperatorName = Lex.getCurStrVal();
Lex.Lex(); // eat the VarName.
@@ -1395,12 +1395,12 @@ Init *TGParser::ParseSimpleValue(Record
std::vector<std::pair<llvm::Init*, std::string> > DagArgs;
if (Lex.getCode() != tgtok::r_paren) {
DagArgs = ParseDagArgList(CurRec);
- if (DagArgs.empty()) return 0;
+ if (DagArgs.empty()) return nullptr;
}
if (Lex.getCode() != tgtok::r_paren) {
TokError("expected ')' in dag init");
- return 0;
+ return nullptr;
}
Lex.Lex(); // eat the ')'
@@ -1437,7 +1437,7 @@ Init *TGParser::ParseSimpleValue(Record
///
Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
Init *Result = ParseSimpleValue(CurRec, ItemType, Mode);
- if (Result == 0) return 0;
+ if (!Result) return nullptr;
// Parse the suffixes now if present.
while (1) {
@@ -1451,20 +1451,20 @@ Init *TGParser::ParseValue(Record *CurRe
SMLoc CurlyLoc = Lex.getLoc();
Lex.Lex(); // eat the '{'
std::vector<unsigned> Ranges = ParseRangeList();
- if (Ranges.empty()) return 0;
+ if (Ranges.empty()) return nullptr;
// Reverse the bitlist.
std::reverse(Ranges.begin(), Ranges.end());
Result = Result->convertInitializerBitRange(Ranges);
- if (Result == 0) {
+ if (!Result) {
Error(CurlyLoc, "Invalid bit range for value");
- return 0;
+ return nullptr;
}
// Eat the '}'.
if (Lex.getCode() != tgtok::r_brace) {
TokError("expected '}' at end of bit range list");
- return 0;
+ return nullptr;
}
Lex.Lex();
break;
@@ -1473,18 +1473,18 @@ Init *TGParser::ParseValue(Record *CurRe
SMLoc SquareLoc = Lex.getLoc();
Lex.Lex(); // eat the '['
std::vector<unsigned> Ranges = ParseRangeList();
- if (Ranges.empty()) return 0;
+ if (Ranges.empty()) return nullptr;
Result = Result->convertInitListSlice(Ranges);
- if (Result == 0) {
+ if (!Result) {
Error(SquareLoc, "Invalid range for list slice");
- return 0;
+ return nullptr;
}
// Eat the ']'.
if (Lex.getCode() != tgtok::r_square) {
TokError("expected ']' at end of list slice");
- return 0;
+ return nullptr;
}
Lex.Lex();
break;
@@ -1492,12 +1492,12 @@ Init *TGParser::ParseValue(Record *CurRe
case tgtok::period:
if (Lex.Lex() != tgtok::Id) { // eat the .
TokError("expected field identifier after '.'");
- return 0;
+ return nullptr;
}
if (!Result->getFieldType(Lex.getCurStrVal())) {
TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" +
Result->getAsString() + "'");
- return 0;
+ return nullptr;
}
Result = FieldInit::get(Result, Lex.getCurStrVal());
Lex.Lex(); // eat field name
@@ -1512,14 +1512,14 @@ Init *TGParser::ParseValue(Record *CurRe
TypedInit *LHS = dyn_cast<TypedInit>(Result);
if (!LHS) {
Error(PasteLoc, "LHS of paste is not typed!");
- return 0;
+ return nullptr;
}
if (LHS->getType() != StringRecTy::get()) {
LHS = UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get());
}
- TypedInit *RHS = 0;
+ TypedInit *RHS = nullptr;
Lex.Lex(); // Eat the '#'.
switch (Lex.getCode()) {
@@ -1539,7 +1539,7 @@ Init *TGParser::ParseValue(Record *CurRe
RHS = dyn_cast<TypedInit>(RHSResult);
if (!RHS) {
Error(PasteLoc, "RHS of paste is not typed!");
- return 0;
+ return nullptr;
}
if (RHS->getType() != StringRecTy::get()) {
@@ -1575,7 +1575,7 @@ TGParser::ParseDagArgList(Record *CurRec
} else {
// DagArg ::= Value (':' VARNAME)?
Init *Val = ParseValue(CurRec);
- if (Val == 0)
+ if (!Val)
return std::vector<std::pair<llvm::Init*, std::string> >();
// If the variable name is present, add it.
@@ -1610,7 +1610,7 @@ std::vector<Init*> TGParser::ParseValueL
std::vector<Init*> Result;
RecTy *ItemType = EltTy;
unsigned int ArgN = 0;
- if (ArgsRec != 0 && EltTy == 0) {
+ if (ArgsRec && !EltTy) {
const std::vector<Init *> &TArgs = ArgsRec->getTemplateArgs();
if (!TArgs.size()) {
TokError("template argument provided to non-template class");
@@ -1626,12 +1626,12 @@ std::vector<Init*> TGParser::ParseValueL
++ArgN;
}
Result.push_back(ParseValue(CurRec, ItemType));
- if (Result.back() == 0) return std::vector<Init*>();
+ if (!Result.back()) return std::vector<Init*>();
while (Lex.getCode() == tgtok::comma) {
Lex.Lex(); // Eat the comma
- if (ArgsRec != 0 && EltTy == 0) {
+ if (ArgsRec && !EltTy) {
const std::vector<Init *> &TArgs = ArgsRec->getTemplateArgs();
if (ArgN >= TArgs.size()) {
TokError("too many template arguments");
@@ -1643,7 +1643,7 @@ std::vector<Init*> TGParser::ParseValueL
++ArgN;
}
Result.push_back(ParseValue(CurRec, ItemType));
- if (Result.back() == 0) return std::vector<Init*>();
+ if (!Result.back()) return std::vector<Init*>();
}
return Result;
@@ -1667,11 +1667,11 @@ Init *TGParser::ParseDeclaration(Record
if (HasField) Lex.Lex();
RecTy *Type = ParseType();
- if (Type == 0) return 0;
+ if (!Type) return nullptr;
if (Lex.getCode() != tgtok::Id) {
TokError("Expected identifier in declaration");
- return 0;
+ return nullptr;
}
SMLoc IdLoc = Lex.getLoc();
@@ -1691,16 +1691,16 @@ Init *TGParser::ParseDeclaration(Record
// Add the value.
if (AddValue(CurRec, IdLoc, RecordVal(DeclName, Type, HasField)))
- return 0;
+ return nullptr;
// If a value is present, parse it.
if (Lex.getCode() == tgtok::equal) {
Lex.Lex();
SMLoc ValLoc = Lex.getLoc();
Init *Val = ParseValue(CurRec, Type);
- if (Val == 0 ||
+ if (!Val ||
SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val))
- return 0;
+ return nullptr;
}
return DeclName;
@@ -1717,7 +1717,7 @@ Init *TGParser::ParseDeclaration(Record
VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) {
if (Lex.getCode() != tgtok::Id) {
TokError("Expected identifier in foreach declaration");
- return 0;
+ return nullptr;
}
Init *DeclName = StringInit::get(Lex.getCurStrVal());
@@ -1726,27 +1726,27 @@ VarInit *TGParser::ParseForeachDeclarati
// If a value is present, parse it.
if (Lex.getCode() != tgtok::equal) {
TokError("Expected '=' in foreach declaration");
- return 0;
+ return nullptr;
}
Lex.Lex(); // Eat the '='
- RecTy *IterType = 0;
+ RecTy *IterType = nullptr;
std::vector<unsigned> Ranges;
switch (Lex.getCode()) {
- default: TokError("Unknown token when expecting a range list"); return 0;
+ default: TokError("Unknown token when expecting a range list"); return nullptr;
case tgtok::l_square: { // '[' ValueList ']'
- Init *List = ParseSimpleValue(0, 0, ParseForeachMode);
+ Init *List = ParseSimpleValue(nullptr, nullptr, ParseForeachMode);
ForeachListValue = dyn_cast<ListInit>(List);
- if (ForeachListValue == 0) {
+ if (!ForeachListValue) {
TokError("Expected a Value list");
- return 0;
+ return nullptr;
}
RecTy *ValueType = ForeachListValue->getType();
ListRecTy *ListType = dyn_cast<ListRecTy>(ValueType);
- if (ListType == 0) {
+ if (!ListType) {
TokError("Value list is not of list type");
- return 0;
+ return nullptr;
}
IterType = ListType->getElementType();
break;
@@ -1754,7 +1754,7 @@ VarInit *TGParser::ParseForeachDeclarati
case tgtok::IntVal: { // RangePiece.
if (ParseRangePiece(Ranges))
- return 0;
+ return nullptr;
break;
}
@@ -1763,7 +1763,7 @@ VarInit *TGParser::ParseForeachDeclarati
Ranges = ParseRangeList();
if (Lex.getCode() != tgtok::r_brace) {
TokError("expected '}' at end of bit range list");
- return 0;
+ return nullptr;
}
Lex.Lex();
break;
@@ -1780,7 +1780,7 @@ VarInit *TGParser::ParseForeachDeclarati
}
if (!IterType)
- return 0;
+ return nullptr;
return VarInit::get(DeclName, IterType);
}
@@ -1800,7 +1800,7 @@ bool TGParser::ParseTemplateArgList(Reco
// Read the first declaration.
Init *TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
- if (TemplArg == 0)
+ if (!TemplArg)
return true;
TheRecToAddTo->addTemplateArg(TemplArg);
@@ -1810,7 +1810,7 @@ bool TGParser::ParseTemplateArgList(Reco
// Read the following declarations.
TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
- if (TemplArg == 0)
+ if (!TemplArg)
return true;
TheRecToAddTo->addTemplateArg(TemplArg);
}
@@ -1828,7 +1828,7 @@ bool TGParser::ParseTemplateArgList(Reco
/// BodyItem ::= LET ID OptionalBitList '=' Value ';'
bool TGParser::ParseBodyItem(Record *CurRec) {
if (Lex.getCode() != tgtok::Let) {
- if (ParseDeclaration(CurRec, false) == 0)
+ if (!ParseDeclaration(CurRec, false))
return true;
if (Lex.getCode() != tgtok::semi)
@@ -1855,13 +1855,13 @@ bool TGParser::ParseBodyItem(Record *Cur
Lex.Lex(); // eat the '='.
RecordVal *Field = CurRec->getValue(FieldName);
- if (Field == 0)
+ if (!Field)
return TokError("Value '" + FieldName + "' unknown!");
RecTy *Type = Field->getType();
Init *Val = ParseValue(CurRec, Type);
- if (Val == 0) return true;
+ if (!Val) return true;
if (Lex.getCode() != tgtok::semi)
return TokError("expected ';' after let expression");
@@ -1927,7 +1927,7 @@ bool TGParser::ParseObjectBody(Record *C
SubClassReference SubClass = ParseSubClassReference(CurRec, false);
while (1) {
// Check for error.
- if (SubClass.Rec == 0) return true;
+ if (!SubClass.Rec) return true;
// Add it.
if (AddSubClass(CurRec, SubClass))
@@ -1998,7 +1998,7 @@ bool TGParser::ParseDef(MultiClass *CurM
} else if (ParseObjectBody(CurRec))
return true;
- if (CurMultiClass == 0) // Def's in multiclasses aren't really defs.
+ if (!CurMultiClass) // Def's in multiclasses aren't really defs.
// See Record::setName(). This resolve step will see any new name
// for the def that might have been created when resolving
// inheritance, values and arguments above.
@@ -2040,9 +2040,9 @@ bool TGParser::ParseForeach(MultiClass *
// Make a temporary object to record items associated with the for
// loop.
- ListInit *ListValue = 0;
+ ListInit *ListValue = nullptr;
VarInit *IterName = ParseForeachDeclaration(ListValue);
- if (IterName == 0)
+ if (!IterName)
return TokError("expected declaration in for");
if (Lex.getCode() != tgtok::In)
@@ -2144,8 +2144,8 @@ std::vector<LetRecord> TGParser::ParseLe
}
Lex.Lex(); // eat the '='.
- Init *Val = ParseValue(0);
- if (Val == 0) return std::vector<LetRecord>();
+ Init *Val = ParseValue(nullptr);
+ if (!Val) return std::vector<LetRecord>();
// Now that we have everything, add the record.
Result.push_back(LetRecord(Name, Bits, Val, NameLoc));
@@ -2228,7 +2228,7 @@ bool TGParser::ParseMultiClass() {
// If there are template args, parse them.
if (Lex.getCode() == tgtok::less)
- if (ParseTemplateArgList(0))
+ if (ParseTemplateArgList(nullptr))
return true;
bool inherits = false;
@@ -2244,7 +2244,7 @@ bool TGParser::ParseMultiClass() {
ParseSubMultiClassReference(CurMultiClass);
while (1) {
// Check for error.
- if (SubMultiClass.MC == 0) return true;
+ if (!SubMultiClass.MC) return true;
// Add it.
if (AddSubMultiClass(CurMultiClass, SubMultiClass))
@@ -2283,7 +2283,7 @@ bool TGParser::ParseMultiClass() {
Lex.Lex(); // eat the '}'.
}
- CurMultiClass = 0;
+ CurMultiClass = nullptr;
return false;
}
@@ -2301,7 +2301,7 @@ InstantiateMulticlassDef(MultiClass &MC,
// as a prefix.
bool IsAnonymous = false;
- if (DefmPrefix == 0) {
+ if (!DefmPrefix) {
DefmPrefix = StringInit::get(GetNewAnonymousName());
IsAnonymous = true;
}
@@ -2310,7 +2310,7 @@ InstantiateMulticlassDef(MultiClass &MC,
StringInit *DefNameString = dyn_cast<StringInit>(DefName);
- if (DefNameString != 0) {
+ if (DefNameString) {
// We have a fully expanded string so there are no operators to
// resolve. We should concatenate the given prefix and name.
DefName =
@@ -2338,13 +2338,13 @@ InstantiateMulticlassDef(MultiClass &MC,
Error(DefmPrefixRange.Start, "Could not resolve "
+ CurRec->getNameInitAsString() + ":NAME to '"
+ DefmPrefix->getAsUnquotedString() + "'");
- return 0;
+ return nullptr;
}
// If the DefNameString didn't resolve, we probably have a reference to
// NAME and need to replace it. We need to do at least this much greedily,
// otherwise nested multiclasses will end up with incorrect NAME expansions.
- if (DefNameString == 0) {
+ if (!DefNameString) {
RecordVal *DefNameRV = CurRec->getValue("NAME");
CurRec->resolveReferencesTo(DefNameRV);
}
@@ -2369,7 +2369,7 @@ InstantiateMulticlassDef(MultiClass &MC,
Error(DefmPrefixRange.Start, "def '" + CurRec->getNameInitAsString() +
"' already defined, instantiating defm with subdef '" +
DefProto->getNameInitAsString() + "'");
- return 0;
+ return nullptr;
}
Records.addDef(CurRec);
@@ -2453,7 +2453,7 @@ bool TGParser::ResolveMulticlassDef(Mult
bool TGParser::ParseDefm(MultiClass *CurMultiClass) {
assert(Lex.getCode() == tgtok::Defm && "Unexpected token!");
SMLoc DefmLoc = Lex.getLoc();
- Init *DefmPrefix = 0;
+ Init *DefmPrefix = nullptr;
if (Lex.Lex() == tgtok::Id) { // eat the defm.
DefmPrefix = ParseObjectName(CurMultiClass);
@@ -2473,10 +2473,10 @@ bool TGParser::ParseDefm(MultiClass *Cur
Lex.Lex();
SMLoc SubClassLoc = Lex.getLoc();
- SubClassReference Ref = ParseSubClassReference(0, true);
+ SubClassReference Ref = ParseSubClassReference(nullptr, true);
while (1) {
- if (Ref.Rec == 0) return true;
+ if (!Ref.Rec) return true;
// To instantiate a multiclass, we need to first get the multiclass, then
// instantiate each def contained in the multiclass with the SubClassRef
@@ -2522,21 +2522,21 @@ bool TGParser::ParseDefm(MultiClass *Cur
// A defm can inherit from regular classes (non-multiclass) as
// long as they come in the end of the inheritance list.
- InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != 0);
+ InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != nullptr);
if (InheritFromClass)
break;
- Ref = ParseSubClassReference(0, true);
+ Ref = ParseSubClassReference(nullptr, true);
}
if (InheritFromClass) {
// Process all the classes to inherit as if they were part of a
// regular 'def' and inherit all record values.
- SubClassReference SubClass = ParseSubClassReference(0, false);
+ SubClassReference SubClass = ParseSubClassReference(nullptr, false);
while (1) {
// Check for error.
- if (SubClass.Rec == 0) return true;
+ if (!SubClass.Rec) return true;
// Get the expanded definition prototypes and teach them about
// the record values the current class to inherit has
@@ -2553,7 +2553,7 @@ bool TGParser::ParseDefm(MultiClass *Cur
if (Lex.getCode() != tgtok::comma) break;
Lex.Lex(); // eat ','.
- SubClass = ParseSubClassReference(0, false);
+ SubClass = ParseSubClassReference(nullptr, false);
}
}
More information about the llvm-commits
mailing list