From 103fed9f013f0b17023b65f45183ea502e78a285 Mon Sep 17 00:00:00 2001 From: Jon Siwek Date: Thu, 7 May 2020 15:05:43 -0700 Subject: [PATCH] Deprecate RecordType::FieldType(), replace with GetFieldType() --- NEWS | 2 + src/CompHash.cc | 6 +-- src/EventHandler.cc | 2 +- src/Expr.cc | 20 ++++----- src/ID.cc | 2 +- src/Type.cc | 29 +++++--------- src/Type.h | 28 ++++++++++++- src/Val.cc | 7 ++-- src/Var.cc | 2 +- src/broker/Data.cc | 4 +- src/input/Manager.cc | 78 ++++++++++++++++++------------------ src/logging/Manager.cc | 6 +-- src/supervisor/Supervisor.cc | 8 ++-- 13 files changed, 105 insertions(+), 89 deletions(-) diff --git a/NEWS b/NEWS index 6d4804b629..50d732d707 100644 --- a/NEWS +++ b/NEWS @@ -146,6 +146,8 @@ Deprecated Functionality - The ``utf16_bytestring_to_utf8_val()`` function is deprecated, use ``utf16_to_utf8_val()`` instead. +- ``RecordType::FieldType()`` is deprecated, use ``RecordType::GetFieldType()`` + Zeek 3.1.0 ========== diff --git a/src/CompHash.cc b/src/CompHash.cc index 01decb854d..416ae38208 100644 --- a/src/CompHash.cc +++ b/src/CompHash.cc @@ -189,7 +189,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0, return nullptr; if ( ! (kp = SingleValHash(type_check, kp, - rt->FieldType(i), + rt->GetFieldType(i).get(), rv_i, optional)) ) return nullptr; } @@ -517,7 +517,7 @@ int CompositeHash::SingleTypeKeySize(BroType* bt, const Val* v, Attributes* a = rt->FieldDecl(i)->attrs.get(); bool optional = (a && a->FindAttr(ATTR_OPTIONAL)); - sz = SingleTypeKeySize(rt->FieldType(i), + sz = SingleTypeKeySize(rt->GetFieldType(i).get(), rv ? rv->Lookup(i) : nullptr, type_check, sz, optional, calc_static_size); @@ -910,7 +910,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0, bool optional = (a && a->FindAttr(ATTR_OPTIONAL)); kp = RecoverOneVal(k, kp, k_end, - rt->FieldType(i), &v, optional); + rt->GetFieldType(i).get(), &v, optional); // An earlier call to reporter->InternalError would have called abort() and broken the // call tree that clang-tidy is relying on to get the error described. diff --git a/src/EventHandler.cc b/src/EventHandler.cc index fa1d90bbd2..4b8f2d11aa 100644 --- a/src/EventHandler.cc +++ b/src/EventHandler.cc @@ -132,7 +132,7 @@ void EventHandler::NewEvent(const zeek::Args& vl) for ( int i = 0; i < args->NumFields(); i++ ) { const char* fname = args->FieldName(i); - BroType* ftype = args->FieldType(i); + const auto& ftype = args->GetFieldType(i); auto fdefault = args->FieldDefault(i); auto rec = make_intrusive(call_argument); diff --git a/src/Expr.cc b/src/Expr.cc index bad027f368..0929de3888 100644 --- a/src/Expr.cc +++ b/src/Expr.cc @@ -2373,7 +2373,7 @@ IntrusivePtr AssignExpr::InitVal(const BroType* t, IntrusivePtr aggr) RecordVal* aggr_r = aggr->AsRecordVal(); - auto v = op2->InitVal(rt->FieldType(td.id), nullptr); + auto v = op2->InitVal(rt->GetFieldType(td.id).get(), nullptr); if ( ! v ) return nullptr; @@ -2867,7 +2867,7 @@ FieldExpr::FieldExpr(IntrusivePtr arg_op, const char* arg_field_name) ExprError("no such field in record"); else { - SetType({NewRef{}, rt->FieldType(field)}); + SetType(rt->GetFieldType(field)); td = rt->FieldDecl(field); if ( rt->IsFieldDeprecated(field) ) @@ -3565,8 +3565,8 @@ RecordCoerceExpr::RecordCoerceExpr(IntrusivePtr arg_op, break; } - BroType* sub_t_i = sub_r->FieldType(i); - BroType* sup_t_i = t_r->FieldType(t_i); + BroType* sub_t_i = sub_r->GetFieldType(i).get(); + BroType* sup_t_i = t_r->GetFieldType(t_i).get(); if ( ! same_type(sup_t_i, sub_t_i) ) { @@ -3685,7 +3685,7 @@ IntrusivePtr RecordCoerceExpr::Fold(Val* v) const } BroType* rhs_type = rhs->Type(); - BroType* field_type = val_type->FieldType(i); + BroType* field_type = val_type->GetFieldType(i).get(); if ( rhs_type->Tag() == TYPE_RECORD && field_type->Tag() == TYPE_RECORD && @@ -3711,11 +3711,11 @@ IntrusivePtr RecordCoerceExpr::Fold(Val* v) const { auto def_val = def->AttrExpr()->Eval(nullptr); BroType* def_type = def_val->Type(); - BroType* field_type = Type()->AsRecordType()->FieldType(i); + const auto& field_type = Type()->AsRecordType()->GetFieldType(i); if ( def_type->Tag() == TYPE_RECORD && field_type->Tag() == TYPE_RECORD && - ! same_type(def_type, field_type) ) + ! same_type(def_type, field_type.get()) ) { auto tmp = def_val->AsRecordVal()->CoerceTo( field_type->AsRecordType()); @@ -3814,7 +3814,7 @@ FlattenExpr::FlattenExpr(IntrusivePtr arg_op) auto tl = make_intrusive(); for ( int i = 0; i < num_fields; ++i ) - tl->Append({NewRef{}, rt->FieldType(i)}); + tl->Append(rt->GetFieldType(i)); Unref(rt); SetType(std::move(tl)); @@ -4809,7 +4809,7 @@ RecordAssignExpr::RecordAssignExpr(const IntrusivePtr& record, int field = lhs->FieldOffset(field_name); if ( field >= 0 && - same_type(lhs->FieldType(field), t->FieldType(j)) ) + same_type(lhs->GetFieldType(field).get(), t->GetFieldType(j).get()) ) { auto fe_lhs = make_intrusive(record, field_name); auto fe_rhs = make_intrusive(IntrusivePtr{NewRef{}, init}, field_name); @@ -5081,7 +5081,7 @@ bool check_and_promote_args(ListExpr* const args, RecordType* types) TypeList* tl = new TypeList(); for ( int i = 0; i < types->NumFields(); ++i ) - tl->Append({NewRef{}, types->FieldType(i)}); + tl->Append(types->GetFieldType(i)); int rval = check_and_promote_exprs(args, tl); Unref(tl); diff --git a/src/ID.cc b/src/ID.cc index 34289ef574..f77c693aaa 100644 --- a/src/ID.cc +++ b/src/ID.cc @@ -187,7 +187,7 @@ void ID::UpdateValAttrs() TypeDecl* fd = rt->FieldDecl(i); if ( ! fd->attrs ) - fd->attrs = make_intrusive(new attr_list, IntrusivePtr{NewRef{}, rt->FieldType(i)}, true, IsGlobal()); + fd->attrs = make_intrusive(new attr_list, rt->GetFieldType(i), true, IsGlobal()); fd->attrs->AddAttr(make_intrusive(ATTR_LOG)); } diff --git a/src/Type.cc b/src/Type.cc index be28490d91..131346ceb1 100644 --- a/src/Type.cc +++ b/src/Type.cc @@ -442,7 +442,7 @@ FuncType::FuncType(IntrusivePtr arg_args, args->Error(err_str); } - arg_types->Append({NewRef{}, args->FieldType(i)}); + arg_types->Append(args->GetFieldType(i)); offsets[i] = i; } @@ -609,10 +609,10 @@ std::optional FuncType::FindPrototype(const RecordType& arg for ( auto i = 0; i < args.NumFields(); ++i ) { - auto ptype = p.args->FieldType(i); - auto desired_type = args.FieldType(i); + const auto& ptype = p.args->GetFieldType(i); + const auto& desired_type = args.GetFieldType(i); - if ( ! same_type(ptype, desired_type) || + if ( ! same_type(ptype.get(), desired_type.get()) || ! streq(args.FieldName(i), p.args->FieldName(i)) ) { matched = false; @@ -700,17 +700,6 @@ bool RecordType::HasField(const char* field) const return FieldOffset(field) >= 0; } -BroType* RecordType::FieldType(const char* field) const - { - int offset = FieldOffset(field); - return offset >= 0 ? FieldType(offset) : nullptr; - } - -BroType* RecordType::FieldType(int field) const - { - return (*types)[field]->type.get(); - } - IntrusivePtr RecordType::FieldDefault(int field) const { const TypeDecl* td = FieldDecl(field); @@ -830,7 +819,7 @@ IntrusivePtr RecordType::GetRecordFieldsVal(const RecordVal* rv) const for ( int i = 0; i < NumFields(); ++i ) { - const BroType* ft = FieldType(i); + const auto& ft = GetFieldType(i); const TypeDecl* fd = FieldDecl(i); Val* fv = nullptr; @@ -844,7 +833,7 @@ IntrusivePtr RecordType::GetRecordFieldsVal(const RecordVal* rv) const auto nr = make_intrusive(internal_type("record_field")->AsRecordType()); - string s = container_type_name(ft); + string s = container_type_name(ft.get()); nr->Assign(0, make_intrusive(s)); nr->Assign(1, val_mgr->Bool(logged)); nr->Assign(2, fv); @@ -1656,10 +1645,10 @@ bool record_promotion_compatible(const RecordType* super_rec, // Orphaned field. continue; - BroType* sub_field_type = sub_rec->FieldType(i); - BroType* super_field_type = super_rec->FieldType(o); + const auto& sub_field_type = sub_rec->GetFieldType(i); + const auto& super_field_type = super_rec->GetFieldType(o); - if ( same_type(sub_field_type, super_field_type) ) + if ( same_type(sub_field_type.get(), super_field_type.get()) ) continue; if ( sub_field_type->Tag() != TYPE_RECORD ) diff --git a/src/Type.h b/src/Type.h index 90a02dedd5..a67164ac6f 100644 --- a/src/Type.h +++ b/src/Type.h @@ -552,8 +552,32 @@ public: ~RecordType() override; bool HasField(const char* field) const override; - BroType* FieldType(const char* field) const override; - BroType* FieldType(int field) const; + + [[deprecated("Remove in v4.1. Use GetFieldType() instead (note it doesn't check for invalid names).")]] + BroType* FieldType(const char* field) const override + { + auto offset = FieldOffset(field); + return offset >= 0 ? GetFieldType(offset).get() : nullptr; + } + + [[deprecated("Remove in v4.1. Use GetFieldType() instead.")]] + BroType* FieldType(int field) const + { return GetFieldType(field).get(); } + + /** + * Looks up a field by name and returns its type. No check for invalid + * field name is performed. + */ + const IntrusivePtr& GetFieldType(const char* field_name) const + { return GetFieldType(FieldOffset(field_name)); } + + /** + * Looks up a field by its index and returns its type. No check for + * invalid field offset is performed. + */ + const IntrusivePtr& GetFieldType(int field_index) const + { return (*types)[field_index]->type; } + IntrusivePtr FieldDefault(int field) const; // A field's offset is its position in the type_decl_list, diff --git a/src/Val.cc b/src/Val.cc index c7a5ccd58a..622510d203 100644 --- a/src/Val.cc +++ b/src/Val.cc @@ -2817,12 +2817,13 @@ IntrusivePtr RecordVal::CoerceTo(const RecordType* t, Val* aggr, bool // Check for allowable optional fields is outside the loop, below. continue; - if ( ar_t->FieldType(t_i)->Tag() == TYPE_RECORD && - ! same_type(ar_t->FieldType(t_i), v->Type()) ) + const auto& ft = ar_t->GetFieldType(t_i); + + if ( ft->Tag() == TYPE_RECORD && ! same_type(ft.get(), v->Type()) ) { auto rhs = make_intrusive(IntrusivePtr{NewRef{}, v}); auto e = make_intrusive(std::move(rhs), - IntrusivePtr{NewRef{}, ar_t->FieldType(t_i)->AsRecordType()}); + cast_intrusive(ft)); ar->Assign(t_i, e->Eval(nullptr)); continue; } diff --git a/src/Var.cc b/src/Var.cc index 9ca437a5e2..33cbc7916e 100644 --- a/src/Var.cc +++ b/src/Var.cc @@ -448,7 +448,7 @@ static bool canonical_arg_types_match(const FuncType* decl, const FuncType* impl return false; for ( auto i = 0; i < canon_args->NumFields(); ++i ) - if ( ! same_type(canon_args->FieldType(i), impl_args->FieldType(i)) ) + if ( ! same_type(canon_args->GetFieldType(i).get(), impl_args->GetFieldType(i).get()) ) return false; return true; diff --git a/src/broker/Data.cc b/src/broker/Data.cc index ba2105264c..2e405e1f1e 100644 --- a/src/broker/Data.cc +++ b/src/broker/Data.cc @@ -403,7 +403,7 @@ struct val_converter { } auto item_val = bro_broker::data_to_val(move(a[idx]), - rt->FieldType(i)); + rt->GetFieldType(i).get()); if ( ! item_val ) return nullptr; @@ -730,7 +730,7 @@ struct type_checker { continue; } - if ( ! data_type_check(a[idx], rt->FieldType(i)) ) + if ( ! data_type_check(a[idx], rt->GetFieldType(i).get()) ) return false; ++idx; diff --git a/src/input/Manager.cc b/src/input/Manager.cc index 72d53ee14b..766a0c559a 100644 --- a/src/input/Manager.cc +++ b/src/input/Manager.cc @@ -366,16 +366,16 @@ bool Manager::CreateEventStream(RecordVal* fval) for ( int i = 0; i < fields->NumFields(); i++ ) { - if ( ! same_type(args[i + 2].get(), fields->FieldType(i) ) ) + if ( ! same_type(args[i + 2].get(), fields->GetFieldType(i).get() ) ) { ODesc desc1; ODesc desc2; args[i + 2]->Describe(&desc1); - fields->FieldType(i)->Describe(&desc2); + fields->GetFieldType(i)->Describe(&desc2); reporter->Error("Input stream %s: Incompatible type for event in field %d. Need type '%s':%s, got '%s':%s", stream_name.c_str(), i + 3, - type_name(fields->FieldType(i)->Tag()), desc2.Description(), + type_name(fields->GetFieldType(i)->Tag()), desc2.Description(), type_name(args[i + 2]->Tag()), desc1.Description()); return false; @@ -497,15 +497,15 @@ bool Manager::CreateTableStream(RecordVal* fval) return false; } - if ( ! same_type(idx->FieldType(j), tl[j].get()) ) + if ( ! same_type(idx->GetFieldType(j).get(), tl[j].get()) ) { ODesc desc1; ODesc desc2; - idx->FieldType(j)->Describe(&desc1); + idx->GetFieldType(j)->Describe(&desc1); tl[j]->Describe(&desc2); reporter->Error("Input stream %s: Table type does not match index type. Need type '%s':%s, got '%s':%s", stream_name.c_str(), - type_name(idx->FieldType(j)->Tag()), desc1.Description(), + type_name(idx->GetFieldType(j)->Tag()), desc1.Description(), type_name(tl[j]->Tag()), desc2.Description()); return false; @@ -526,7 +526,7 @@ bool Manager::CreateTableStream(RecordVal* fval) const BroType* compare_type = val.get(); if ( want_record->InternalInt() == 0 ) - compare_type = val->FieldType(0); + compare_type = val->GetFieldType(0).get(); if ( ! same_type(table_yield, compare_type) ) { @@ -606,11 +606,11 @@ bool Manager::CreateTableStream(RecordVal* fval) return false; } else if ( want_record->InternalInt() == 0 - && val && !same_type(args[3].get(), val->FieldType(0) ) ) + && val && !same_type(args[3].get(), val->GetFieldType(0).get() ) ) { ODesc desc1; ODesc desc2; - val->FieldType(0)->Describe(&desc1); + val->GetFieldType(0)->Describe(&desc1); args[3]->Describe(&desc2); reporter->Error("Input stream %s: Table event's value attribute does not match. Need '%s', got '%s'", stream_name.c_str(), desc1.Description(), desc2.Description()); @@ -892,7 +892,7 @@ bool Manager::UnrollRecordType(vector *fields, const RecordType *rec, for ( int i = 0; i < rec->NumFields(); i++ ) { - if ( ! IsCompatibleType(rec->FieldType(i)) ) + if ( ! IsCompatibleType(rec->GetFieldType(i).get()) ) { string name = nameprepend + rec->FieldName(i); // If the field is a file, function, or opaque @@ -901,21 +901,21 @@ bool Manager::UnrollRecordType(vector *fields, const RecordType *rec, // stuff that we actually cannot read :) if ( allow_file_func ) { - if ( ( rec->FieldType(i)->Tag() == TYPE_FILE || - rec->FieldType(i)->Tag() == TYPE_FUNC || - rec->FieldType(i)->Tag() == TYPE_OPAQUE ) && + if ( ( rec->GetFieldType(i)->Tag() == TYPE_FILE || + rec->GetFieldType(i)->Tag() == TYPE_FUNC || + rec->GetFieldType(i)->Tag() == TYPE_OPAQUE ) && rec->FieldDecl(i)->FindAttr(ATTR_OPTIONAL) ) { - reporter->Info("Encountered incompatible type \"%s\" in type definition for field \"%s\" in ReaderFrontend. Ignoring optional field.", type_name(rec->FieldType(i)->Tag()), name.c_str()); + reporter->Info("Encountered incompatible type \"%s\" in type definition for field \"%s\" in ReaderFrontend. Ignoring optional field.", type_name(rec->GetFieldType(i)->Tag()), name.c_str()); continue; } } - reporter->Error("Incompatible type \"%s\" in type definition for for field \"%s\" in ReaderFrontend", type_name(rec->FieldType(i)->Tag()), name.c_str()); + reporter->Error("Incompatible type \"%s\" in type definition for for field \"%s\" in ReaderFrontend", type_name(rec->GetFieldType(i)->Tag()), name.c_str()); return false; } - if ( rec->FieldType(i)->Tag() == TYPE_RECORD ) + if ( rec->GetFieldType(i)->Tag() == TYPE_RECORD ) { string prep = nameprepend + rec->FieldName(i) + "."; @@ -925,7 +925,7 @@ bool Manager::UnrollRecordType(vector *fields, const RecordType *rec, return false; } - if ( !UnrollRecordType(fields, rec->FieldType(i)->AsRecordType(), prep, allow_file_func) ) + if ( !UnrollRecordType(fields, rec->GetFieldType(i)->AsRecordType(), prep, allow_file_func) ) { return false; } @@ -937,15 +937,15 @@ bool Manager::UnrollRecordType(vector *fields, const RecordType *rec, string name = nameprepend + rec->FieldName(i); const char* secondary = nullptr; IntrusivePtr c; - TypeTag ty = rec->FieldType(i)->Tag(); + TypeTag ty = rec->GetFieldType(i)->Tag(); TypeTag st = TYPE_VOID; bool optional = false; if ( ty == TYPE_TABLE ) - st = rec->FieldType(i)->AsSetType()->Indices()->GetPureType()->Tag(); + st = rec->GetFieldType(i)->AsSetType()->Indices()->GetPureType()->Tag(); else if ( ty == TYPE_VECTOR ) - st = rec->FieldType(i)->AsVectorType()->YieldType()->Tag(); + st = rec->GetFieldType(i)->AsVectorType()->YieldType()->Tag(); else if ( ty == TYPE_PORT && rec->FieldDecl(i)->FindAttr(ATTR_TYPE_COLUMN) ) @@ -1027,9 +1027,9 @@ Val* Manager::ValueToIndexVal(const Stream* i, int num_fields, const RecordType int position = 0; - if ( num_fields == 1 && type->FieldType(0)->Tag() != TYPE_RECORD ) + if ( num_fields == 1 && type->GetFieldType(0)->Tag() != TYPE_RECORD ) { - idxval = ValueToVal(i, vals[0], type->FieldType(0), have_error); + idxval = ValueToVal(i, vals[0], type->GetFieldType(0).get(), have_error); position = 1; } else @@ -1037,12 +1037,12 @@ Val* Manager::ValueToIndexVal(const Stream* i, int num_fields, const RecordType ListVal *l = new ListVal(TYPE_ANY); for ( int j = 0 ; j < type->NumFields(); j++ ) { - if ( type->FieldType(j)->Tag() == TYPE_RECORD ) + if ( type->GetFieldType(j)->Tag() == TYPE_RECORD ) l->Append({AdoptRef{}, ValueToRecordVal(i, vals, - type->FieldType(j)->AsRecordType(), &position, have_error)}); + type->GetFieldType(j)->AsRecordType(), &position, have_error)}); else { - l->Append({AdoptRef{}, ValueToVal(i, vals[position], type->FieldType(j), have_error)}); + l->Append({AdoptRef{}, ValueToVal(i, vals[position], type->GetFieldType(j).get(), have_error)}); position++; } } @@ -1158,7 +1158,7 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals) valval = nullptr; else if ( stream->num_val_fields == 1 && !stream->want_record ) - valval = ValueToVal(i, vals[position], stream->rtype->FieldType(0), convert_error); + valval = ValueToVal(i, vals[position], stream->rtype->GetFieldType(0).get(), convert_error); else valval = ValueToRecordVal(i, vals, stream->rtype, &position, convert_error); @@ -1502,14 +1502,14 @@ int Manager::SendEventStreamEvent(Stream* i, EnumVal* type, const Value* const * { Val* val = nullptr; - if ( stream->fields->FieldType(j)->Tag() == TYPE_RECORD ) + if ( stream->fields->GetFieldType(j)->Tag() == TYPE_RECORD ) val = ValueToRecordVal(i, vals, - stream->fields->FieldType(j)->AsRecordType(), + stream->fields->GetFieldType(j)->AsRecordType(), &position, convert_error); else { - val = ValueToVal(i, vals[position], stream->fields->FieldType(j), convert_error); + val = ValueToVal(i, vals[position], stream->fields->GetFieldType(j).get(), convert_error); position++; } @@ -1547,7 +1547,7 @@ int Manager::PutTable(Stream* i, const Value* const *vals) valval = nullptr; else if ( stream->num_val_fields == 1 && stream->want_record == 0 ) - valval = ValueToVal(i, vals[position], stream->rtype->FieldType(0), convert_error); + valval = ValueToVal(i, vals[position], stream->rtype->GetFieldType(0).get(), convert_error); else valval = ValueToRecordVal(i, vals, stream->rtype, &position, convert_error); @@ -1845,10 +1845,10 @@ bool Manager::SendEvent(ReaderFrontend* reader, const string& name, const int nu Val* v = ValueToVal(i, vals[j], convert_error); vl.emplace_back(AdoptRef{}, v); - if ( v && ! convert_error && ! same_type(type->FieldType(j), v->Type()) ) + if ( v && ! convert_error && ! same_type(type->GetFieldType(j).get(), v->Type()) ) { convert_error = true; - type->FieldType(j)->Error("SendEvent types do not match", v->Type()); + type->GetFieldType(j)->Error("SendEvent types do not match", v->Type()); } } @@ -1916,8 +1916,8 @@ RecordVal* Manager::ListValToRecordVal(ListVal* list, RecordType *request_type, assert ( (*position) <= maxpos ); Val* fieldVal = nullptr; - if ( request_type->FieldType(i)->Tag() == TYPE_RECORD ) - fieldVal = ListValToRecordVal(list, request_type->FieldType(i)->AsRecordType(), position); + if ( request_type->GetFieldType(i)->Tag() == TYPE_RECORD ) + fieldVal = ListValToRecordVal(list, request_type->GetFieldType(i)->AsRecordType(), position); else { fieldVal = list->Idx(*position).get(); @@ -1940,10 +1940,10 @@ RecordVal* Manager::ValueToRecordVal(const Stream* stream, const Value* const *v for ( int i = 0; i < request_type->NumFields(); i++ ) { Val* fieldVal = nullptr; - if ( request_type->FieldType(i)->Tag() == TYPE_RECORD ) - fieldVal = ValueToRecordVal(stream, vals, request_type->FieldType(i)->AsRecordType(), position, have_error); - else if ( request_type->FieldType(i)->Tag() == TYPE_FILE || - request_type->FieldType(i)->Tag() == TYPE_FUNC ) + if ( request_type->GetFieldType(i)->Tag() == TYPE_RECORD ) + fieldVal = ValueToRecordVal(stream, vals, request_type->GetFieldType(i)->AsRecordType(), position, have_error); + else if ( request_type->GetFieldType(i)->Tag() == TYPE_FILE || + request_type->GetFieldType(i)->Tag() == TYPE_FUNC ) { // If those two unsupported types are encountered here, they have // been let through by the type checking. @@ -1956,7 +1956,7 @@ RecordVal* Manager::ValueToRecordVal(const Stream* stream, const Value* const *v } else { - fieldVal = ValueToVal(stream, vals[*position], request_type->FieldType(i), have_error); + fieldVal = ValueToVal(stream, vals[*position], request_type->GetFieldType(i).get(), have_error); (*position)++; } diff --git a/src/logging/Manager.cc b/src/logging/Manager.cc index 23a295238b..44327ee43e 100644 --- a/src/logging/Manager.cc +++ b/src/logging/Manager.cc @@ -247,7 +247,7 @@ bool Manager::CreateStream(EnumVal* id, RecordVal* sval) if ( ! (columns->FieldDecl(i)->FindAttr(ATTR_LOG)) ) continue; - if ( ! threading::Value::IsCompatibleType(columns->FieldType(i)) ) + if ( ! threading::Value::IsCompatibleType(columns->GetFieldType(i).get()) ) { reporter->Error("type of field '%s' is not support for logging output", columns->FieldName(i)); @@ -409,7 +409,7 @@ bool Manager::TraverseRecord(Stream* stream, Filter* filter, RecordType* rt, rtype = rt; } - BroType* t = rtype->FieldType(i); + const auto& t = rtype->GetFieldType(i); // Ignore if &log not specified. if ( ! rtype->FieldDecl(i)->FindAttr(ATTR_LOG) ) @@ -744,7 +744,7 @@ bool Manager::Write(EnumVal* id, RecordVal* columns_arg) path_arg = val_mgr->EmptyString(); IntrusivePtr rec_arg; - BroType* rt = filter->path_func->FType()->Args()->FieldType("rec"); + const auto& rt = filter->path_func->FType()->Args()->GetFieldType("rec"); if ( rt->Tag() == TYPE_RECORD ) rec_arg = columns->CoerceTo(rt->AsRecordType(), true); diff --git a/src/supervisor/Supervisor.cc b/src/supervisor/Supervisor.cc index 75e08bdef1..6ae8038fcd 100644 --- a/src/supervisor/Supervisor.cc +++ b/src/supervisor/Supervisor.cc @@ -1123,14 +1123,14 @@ IntrusivePtr Supervisor::NodeConfig::ToRecord() const if ( cpu_affinity ) rval->Assign(rt->FieldOffset("cpu_affinity"), val_mgr->Int(*cpu_affinity)); - auto st = BifType::Record::Supervisor::NodeConfig->FieldType("scripts"); + const auto& st = rt->GetFieldType("scripts"); auto scripts_val = new VectorVal(st->AsVectorType()); rval->Assign(rt->FieldOffset("scripts"), scripts_val); for ( const auto& s : scripts ) scripts_val->Assign(scripts_val->Size(), make_intrusive(s)); - auto tt = BifType::Record::Supervisor::NodeConfig->FieldType("cluster"); + const auto& tt = rt->GetFieldType("cluster"); auto cluster_val = new TableVal({NewRef{}, tt->AsTableType()}); rval->Assign(rt->FieldOffset("cluster"), cluster_val); @@ -1314,8 +1314,8 @@ void Supervisor::SupervisedNode::Init(zeek::Options* options) const IntrusivePtr Supervisor::Status(std::string_view node_name) { auto rval = make_intrusive(BifType::Record::Supervisor::Status); - auto tt = BifType::Record::Supervisor::Status->FieldType("nodes"); - auto node_table_val = new TableVal({NewRef{}, tt->AsTableType()}); + const auto& tt = BifType::Record::Supervisor::Status->GetFieldType("nodes"); + auto node_table_val = new TableVal(cast_intrusive(tt)); rval->Assign(0, node_table_val); if ( node_name.empty() )