diff options
Diffstat (limited to 'lib/TableGen/TGParser.cpp')
| -rw-r--r-- | lib/TableGen/TGParser.cpp | 374 |
1 files changed, 187 insertions, 187 deletions
diff --git a/lib/TableGen/TGParser.cpp b/lib/TableGen/TGParser.cpp index 4ba769c51e..f94c6f62a4 100644 --- a/lib/TableGen/TGParser.cpp +++ b/lib/TableGen/TGParser.cpp @@ -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() const { } // 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, SMLoc Loc, Init *ValName, 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, SMLoc Loc, Init *ValName, // 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, SMLoc Loc, Init *ValName, } 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 *CurRec, SMLoc Loc, IterSet &IterVals){ 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 *CurRec, SMLoc Loc, IterSet &IterVals){ 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(MultiClass *CurMultiClass) { // 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(MultiClass *CurMultiClass) { 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, bool isDefm) { } 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, bool isDefm) { 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 *CurMC) { 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 *CurMC) { 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::vector<unsigned> &Ranges) { /// 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 *CurRec, 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 *CurRec) { 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 *CurRec) { 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 *CurRec) { } 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 *CurRec) { 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 *CurRec) { } 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 *CurRec) { 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 *CurRec) { 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 *CurRec) { 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 *CurRec) { ->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 *CurRec) { } 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 *CurRec) { 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 *CurRec) { 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 *CurRec) { /// 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 *CurRec, RecTy *ItemType, // 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 *CurRec, RecTy *ItemType, 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 *CurRec, RecTy *ItemType, 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 *CurRec, RecTy *ItemType, 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 *CurRec, RecTy *ItemType, 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 *CurRec, RecTy *ItemType, 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 *CurRec, RecTy *ItemType, 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 *CurRec, RecTy *ItemType, 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 *CurRec, RecTy *ItemType, 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 *CurRec, RecTy *ItemType, /// 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 *CurRec, RecTy *ItemType, IDParseMode Mode) { 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 *CurRec, RecTy *ItemType, IDParseMode Mode) { 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 *CurRec, RecTy *ItemType, IDParseMode Mode) { 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 *CurRec, RecTy *ItemType, IDParseMode Mode) { 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 *CurRec, RecTy *ItemType, IDParseMode Mode) { 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::ParseValueList(Record *CurRec, Record *ArgsRec, 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::ParseValueList(Record *CurRec, Record *ArgsRec, ++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::ParseValueList(Record *CurRec, Record *ArgsRec, ++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 *CurRec, 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 *CurRec, // 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 *CurRec, 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::ParseForeachDeclaration(ListInit *&ForeachListValue) { // 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::ParseForeachDeclaration(ListInit *&ForeachListValue) { case tgtok::IntVal: { // RangePiece. if (ParseRangePiece(Ranges)) - return 0; + return nullptr; break; } @@ -1763,7 +1763,7 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { 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::ParseForeachDeclaration(ListInit *&ForeachListValue) { } if (!IterType) - return 0; + return nullptr; return VarInit::get(DeclName, IterType); } @@ -1800,7 +1800,7 @@ bool TGParser::ParseTemplateArgList(Record *CurRec) { // 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(Record *CurRec) { // 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(Record *CurRec) { /// 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 *CurRec) { 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 *CurRec) { 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 *CurMultiClass) { } 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 *CurMultiClass) { // 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::ParseLetList() { } 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(MultiClass &MC, 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 *CurMultiClass) { 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 *CurMultiClass) { // 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 *CurMultiClass) { if (Lex.getCode() != tgtok::comma) break; Lex.Lex(); // eat ','. - SubClass = ParseSubClassReference(0, false); + SubClass = ParseSubClassReference(nullptr, false); } } |